博客园_刘冬的博客

开源框架完美组合之Spring.NET + NHibernate + ASP.NET MVC + jQuery + easyUI 中英文双语言小型企业网站Demo

2011-08-18T17:53:00Z

热衷于开源框架探索的我发现ASP.NET MVC与jQuery easyUI的组合很给力。由于原先一直受Ext JS框架的licence所苦恼，于是痛下决心寻找一个完全免费的js框架——easyUI。它有完整的demo和强大AIP手册，使我在开发过程中得心应手。以下是这篇博文Demo程序的演示效果：

解决方案如图1所示

图1

Domain：领域模型

Dao：持久层

Service：服务层

WebSite：表示层

Common：通用类

首页如图2所示，可以选择中文和English。

图2

英文首页如图3所示

图3

公司简介效果如图4所示

图4

后台登陆页面如图5所示

图5

后台首页如图6所示

图6

后台首页的代码html为：

<body class="easyui-layout">
    <div region="north" border="false" style="height: 100px; background-color: #E0ECFF;">
        <div style="height: 80px; clear: both;">
            <div style="width: 150px;">
            </div>
            <div style="text-align: center; width: 150px; line-height: 80px;">
               <img alt="logo" src="/Images/logo_small.jpg" onclick="window.open('/Index.html')" />
            </div>
        </div>
        <div style="height: 20px;text-align:right">
        <div>
        登陆用户：<a href="#" onclick=""><%= ((dynamic)ViewData["User"]).Name %></a>  
                <a href="#" onclick="showChangePasswordWin();">修改密码</a>   <a href="/Home/LogOut/">
                    退出系统</a>
                      <a href="http://member.webweb.com/" target="_blank">空间管理</a>  
                    <a href="http://new.cnzz.com/" target="_blank">站长在线</a>    
                    </div>
        </div>
    </div>
    <div region="west" split="true" title="<font color='#993333'>系统菜单</font>" style="width: 150px;">
        <div class="easyui-accordion" fit="true" border="false" style="background-color: #E0ECFF;
            background-repeat: repeat-x;">
            <div title="资料管理" style="overflow: auto;">
                <table border="0" cellspacing="1" cellpadding="1" align="center">
                    <tr>
                        <td height="23">
                            <a href="#" onclick="showTab('Forum',$(this).html());">版块管理</a>
                        </td>
                    </tr>
                    <tr>
                        <td height="23">
                            <a href="#" onclick="showTab('Category',$(this).html());">分类管理</a>
                        </td>
                    </tr>
                </table>
            </div>
            <% foreach (var item in (this.ViewData["CategoryList"] as IList<Domain.Category>).GroupBy(g => g.Forum))
               { %>
            <div title="<%= item.Key.Name %>" style="overflow: auto;">
                <table border="0" cellspacing="1" cellpadding="1" align="center">
                    <%foreach (var value in item)
                      {  %>
                    <tr>
                        <td height="23">
                            <a href="#" onclick="showArticle('<%= value.ID %>',$(this).html());"><%= value.Name %></a>
                        </td>
                    </tr>
                    <% } %>
                </table>
            </div>
            <% } %>
            <div title="系统管理" style="overflow: auto;">
                <table border="0" cellspacing="1" cellpadding="1" align="center">
                    <tr>
                        <td height="23">
                            <a href="#" onclick="showTab('UserInfo',$(this).html());">管理员用户管理</a>
                        </td>
                    </tr>
                </table>
            </div>
        </div>
    </div>
    <div region="south" border="false" style="height: 20px; background: #A9FACD; text-align: center;
        line-height: 20px; background-image: url(/Images/bg_bottom.gif);">
        Copy Right ®2010-2011</div>
    <div region="center">
        <div id="tab" class="easyui-tabs" fit="true" border="false">
            <div title="首页" style="padding: 20px; overflow: hidden;">
                <table width="98%" border="0" cellpadding="3" align="center" cellspacing="0" bgcolor="#F1EAE0">
                    <tr>
                        <td width="100%" bgcolor="#cccccc" height="5">
                        </td>
                    </tr>
                    <tr>
                        <td width="100%" class="change_td" style="cursor: hand">
                            服务器参数
                        </td>
                    </tr>
                </table>
                <table cellspacing="1" cellpadding="3" width="98%" align="center" bgcolor="#ffffff"
                    border="0">
                    <tbody>
                        <tr>
                            <td class="th1" align="center" colspan="2" style="height: 25px">
                                服务器信息统计
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td width="50%" style="height: 24px">
                                 <strong>服务器名</strong>：<%=System.Environment.MachineName%>
                            </td>
                            <td width="50%" style="height: 24px">
                                 <b>服务器端口：</b><%= HttpContext.Current.Request.ServerVariables["Server_Port"].ToString() %>
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td width="50%" style="height: 23px">
                                 <b>脚本解释引擎：</b><%=System.Environment.Version%>
                            </td>
                            <td width="50%" style="height: 23px">
                                <b> 站点物理路径：</b><%=HttpContext.Current.Request.PhysicalApplicationPath.ToString() %>
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td width="50%" style="height: 23px">
                                 <b>服务器CPU个数：</b><%=System.Environment.ProcessorCount %>
                            </td>
                            <td width="50%" style="height: 23px">
                                 <b>服务器IIS版本：</b><%=Request.ServerVariables["SERVER_SOFTWARE"]%>
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td width="50%">
                                 <b>开机运行时长</b>：<%=(System.Environment.TickCount/3600000).ToString("N2")%>
                                小时
                            </td>
                            <td width="50%">
                                <b> 服务器时间：</b><%=DateTime.Now.ToString() %>
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td colspan="2">
                                 <b>服务器操作系统：</b><span>
                                    <%=System.Environment.OSVersion.ToString()%></span>
                            </td>
                        </tr>
                        <tr bgcolor="#f9fbf0">
                            <td colspan="2">
                                 
                            </td>
                        </tr>
                    </tbody>
                </table>
            </div>
        </div>
    </div>
    <div id="winPassword" class="easyui-window" closed="true" modal="true" title="修改密码"
        style="width: 280px; height: 160px;" collapsible="false" minimizable="false"
        maximizable="false">
        <div class="easyui-layout" fit="true">
            <div region="center" border="false" style="padding: 10px; background: #fff; border: 1px solid #ccc;">
                <table>
                    <tr>
                        <td>
                            旧密码：
                        </td>
                        <td>
                            <input type="password" id="iptOldPassword" />
                        </td>
                    </tr>
                    <tr>
                        <td>
                            新密码：
                        </td>
                        <td>
                            <input type="password" id="iptPassword" />
                        </td>
                    </tr>
                    <tr>
                        <td>
                            确认密码：
                        </td>
                        <td>
                            <input type="password" id="iptNewPassword" />
                        </td>
                    </tr>
                </table>
            </div>
            <div region="south" border="false" style="text-align: right; height: 30px; line-height: 30px;">
                <a class="easyui-linkbutton" iconcls="icon-ok" href="javascript:void(0)" onclick="changePassword()">
                    确定</a> <a class="easyui-linkbutton" iconcls="icon-cancel" href="javascript:void(0)"
                        onclick="$('#winPassword').window('close');">取消</a>
            </div>
        </div>
    </div>
</body>

可以进行版块和分类的管理，如图7和图8所示。

图7

图8

选择列表模式的分类可以添加列表内容,如图9所示。

图9

easyUI的datagrid代码如下：

$('#grid').datagrid({
                title: '<%= ((Domain.Category)this.ViewData["entity"]).Name %>信息',
                iconCls: 'icon-save',
                nowrap: false,
                striped: true,
                url: '/Article/LoadAllByPage/',
                sortName: 'CreateDate',
                sortOrder: 'desc',
                remoteSort: true,
                fitColumns: true,
                fit: true,
                idField: 'ID',
                queryParams: { categoryId: '<%= ((Domain.Category)this.ViewData["entity"]).ID %>' },
                frozenColumns: [[
                    { field: 'ID', checkbox: true }
                ]],

                columns: [[
                    { field: 'CreateDate', title: '建立日期', width: 100,
                        formatter: function (value, rec) {
                            return eval("new " + value.substr(1, value.length - 2)).toLocaleDateString();
                        }
                    },
                    { field: 'Name', title: '中文标题', width: 80, align: 'right' },
                    { field: 'NameEn', title: '英文标题', width: 80, align: 'right' },
                    { field: 'IsFirst', title: '是否置顶', width: 40, align: 'right',
                        formatter: function (value, rec) {
                            return value ? '是' : '否';
                        }
                    },
                    { field: 'IsEnabled', title: '状态', width: 40, align: 'right',
                        formatter: function (value, rec) {
                            return value ? '显示' : '隐藏';
                        }
                    },
                    { field: 'From', title: '来源', width: 80, align: 'right' },
                    { field: 'ViewCount', title: '浏览次数', width: 40, align: 'left' },
                    { field: 'UpdateDate', title: '最后更新日期', width: 100,
                        formatter: function (value, rec) {
                            return eval("new " + value.substr(1, value.length - 2)).toLocaleDateString();
                        }
                    }
                ]],
                pagination: true,
                rownumbers: true,
                toolbar: ['-', {
                    id: 'btnSave',
                    text: '添加',
                    iconCls: 'icon-add',
                    handler: function () {
                        this.href = '/Article/View/?categoryId=<%= ((Domain.Category)this.ViewData["entity"]).ID %>';
                    }
                }, '-', {
                    id: 'btnUpdate',
                    text: '修改',
                    iconCls: 'icon-save',
                    handler: function () {

                        var row = $('#grid').datagrid('getSelected');
                        if (row) {
                            this.href = '/Article/View/' + row.ID + '/?categoryId=<%= ((Domain.Category)this.ViewData["entity"]).ID %>';
                        }
                        else {
                            $.messager.alert('提示', '请选择要修改的数据');
                            return;
                        }

                    }
                }, '-', {
                    id: 'btnDelete',
                    text: '删除',
                    disabled: false,
                    iconCls: 'icon-cut',
                    handler: function () {

                        var rows = $('#grid').datagrid('getSelections');
                        if (!rows || rows.length == 0) {
                            $.messager.alert('提示', '请选择要删除的数据');
                            return;
                        }
                        var parm;
                        $.each(rows, function (i, n) {
                            if (i == 0) {
                                parm = "idList=" + n.ID;
                            }
                            else {
                                parm += "&idList=" + n.ID;
                            }
                        });
                        $.messager.confirm('提示', '是否删除这些数据?', function (r) {
                            if (!r) {
                                return;
                            }

                            $.ajax({
                                type: "POST",
                                url: "/Article/Delete/",
                                data: parm,
                                success: function (msg) {
                                    if (msg.IsSuccess) {
                                        $.messager.alert('提示', '删除成功！', "info", function () {
                                            $('#grid').datagrid("reload");
                                        });
                                    }
                                },
                                error: function () {
                                    $.messager.alert('错误', '删除失败！', "error");
                                }
                            });
                        });
                    }
                }, '-']

Controller的载入JSON数据的代码为：

        [Authorize]
        public ActionResult LoadAllByPage(Guid categoryId, int page, int rows, string order, string sort)
        {
            long total = 0;
            var list = this.ArticleManager.LoadAllByPage(out total, categoryId, page, rows, order, sort).Select(entity => new
            {
                entity.Name,
                entity.NameEn,
                entity.ID,
                entity.CreateDate,
                entity.UpdateDate,
                entity.IsEnabled,
                entity.IsFirst,
                entity.ViewCount,
                entity.From,
                CategoryId = entity.Category.ID,
                CategoryName = entity.Category.Name
            });

            var result = new { total = total, rows = list.ToList() };

            return Json(result);
        }

开发环境为VS2010，数据库是根据NHibernate的方言任意配置，我使用的是SQLite数据库。

<add key="provider" value="System.Data.SQLite" />
    <add key="connectionString" value="Data Source=|DataDirectory|DataBase.db;Version=3;FailIfMissing=False;" />
    <add key="dialect" value="NHibernate.Dialect.SQLiteDialect" />
    <add key="driver_class" value="NHibernate.Driver.SQLite20Driver" />

    
    <add key="hbm2ddl.auto" value="update" />

代码下载

作者：刘冬.NET

出处：http://www.cnblogs.com/GoodHelper/archive/2011/08/19/SpringNetFramework_Step3.html

欢迎转载，但须保留版权

本文链接

Android与IIS身份验证——Form验证

2011-08-18T16:16:00Z

内容摘要

前言

设计思路

ASP.NET服务器端

Android客户端

运行结果

上篇《Android与IIS身份验证——基本验证》实现了Android客户端与IIS的简单验证。而这种验证方式虽然使用起来比较简单，但是也有很多缺点。如，安全性较差，账号密码设置不灵活。让我们回顾一下ASP.NET的身份验证方式：Windows、Form和Passport。这三种验证方式中，Form身份验证方式最经常使用，因为它有很多优越性，其优点我就不一一介绍了。那么，怎样实现Android客户端与IIS的Form身份验证呢？我整理了一下，需要以下几个步骤：

一、设计思路

Android客户端访问IIS服务器时，当没有登陆时，ASP.NET通过Form集成验证方法会返回一个登陆页面。然后输入正确的用户名和密码，就可以进入主程序了。流程如图1.1所示。

图1.1

在Android客户端访问以IIS为宿主的ASP.NET服务器时，返回JSON格式来传递数据。客户端中，根据返回数据的不同而判断当前状态是否已登陆。由于Form验证是保存了Cookie，所示每次调用Http请求之前要先添加上次请求的Cookie。

二、ASP.NET服务器端

创建一个ASP.NET MVC网站项目。

首先，由于每次请求都返回JSON格式的数据，我们编写一个Model类来承载数据。

    public class ResponseResult
    {
        /// <summary>
        /// 是否已登录
        /// </summary>
        public bool IsAuthenticated { get; set; }

        /// <summary>
        /// 是否执行成功
        /// </summary>
        public bool IsSuccess { get; set; }

        /// <summary>
        /// 登录账号
        /// </summary>
        public string Identity { get; set; }

        /// <summary>
        /// 执行结果
        /// </summary>
        public object Result { get; set; }
    }

接着，编写HomeController：

    [HandleError]
    public class HomeController : Controller
    {
        [Authorize]
        public ActionResult Index()
        {
            return Json(new ResponseResult
            {
                Result = "登陆成功",
                IsAuthenticated = true,
                IsSuccess = true,
                Identity = this.User.Identity.Name
            }, "text/html", JsonRequestBehavior.AllowGet);
        }

        public ActionResult LogOn()
        {
            return Json(new ResponseResult
            {
                Result = "您尚未登录",
                IsSuccess = true
            }, "text/html", JsonRequestBehavior.AllowGet);
        }

        public ActionResult Register(string account, string password)
        {
            if (account == "liudong" && password == "123")
            {
                FormsAuthentication.SetAuthCookie(account, false);
                return Json(new ResponseResult
                {
                    Result = "登录成功",
                    IsSuccess = true,
                    IsAuthenticated = true,
                    Identity = account
                }, "text/html", JsonRequestBehavior.AllowGet);
            }
            else
            {
                return Json(new ResponseResult
                {
                    Result = "用户名或密码错误",
                }, "text/html", JsonRequestBehavior.AllowGet);
            }
        }

Index Action为登陆认证后才能访问的Action。

LogOn Action为未登陆时跳转的Action。

然后，在Web.config中配置Form验证配置

最后，配置IIS，部署ASP.NET MV网站，如图2.1所示。

图2.1

三、Android客户端

首先，编写一个调用Http请求的类。

package ld.com.authorize;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;

import org.apache.http.client.CookieStore;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;

import android.util.Log;

public abstract class HttpHelper {

    private final static String TAG = "HttpHelper";
    private final static String SERVER_URL = "http://192.168.1.104:180/Home/";

    private static CookieStore cookieStore;

    public static String invoke(String actionName, List<NameValuePair> params) {
        String result = null;
        try {
            String url = SERVER_URL + actionName + "/";
            Log.d(TAG, "url is" + url);

            HttpPost httpPost = new HttpPost(url);
            if (params != null && params.size() > 0) {
                HttpEntity entity = new UrlEncodedFormEntity(params, "UTF-8");
                httpPost.setEntity(entity);
            }

            DefaultHttpClient httpClient = new DefaultHttpClient();

            // 添加Cookie
            if (cookieStore != null) {
                httpClient.setCookieStore(cookieStore);
            }

            HttpResponse httpResponse = httpClient.execute(httpPost);

            StringBuilder builder = new StringBuilder();
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    httpResponse.getEntity().getContent()));
            for (String s = reader.readLine(); s != null; s = reader.readLine()) {
                builder.append(s);
            }
            result = builder.toString();
            Log.d(TAG, "result is ( " + result + " )");

            // 保存Cookie
            cookieStore = ((AbstractHttpClient) httpClient).getCookieStore();
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        Log.d(TAG, "over");
        return result;
    }

    public static String invoke(String actionName) {
        return invoke(actionName, null);
    }
}

注意的是，需要存储一个全局的Cookie，在每次调用前添加上去，再在调用j结束后保存它。

接着，添加两个布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <TextView android:text="账号" android:layout_width="fill_parent"
        android:layout_height="20dip" />

    <EditText android:layout_width="fill_parent" android:hint="请输入账号"
        android:layout_height="40dip" android:id="@+id/edtAccount" />

    <TextView android:text="密码" android:layout_width="fill_parent"
        android:layout_height="20dip" />

    <EditText android:layout_width="fill_parent" android:hint="请输入密码"
        android:password="true" android:layout_height="40dip" android:id="@+id/edtPassword" />

    <Button android:text="登录" android:layout_width="fill_parent"
        android:layout_height="40dip" android:id="@+id/btnLogon" />
</LinearLayout>

然后、编写登陆和主Activity

package ld.com.authorize;

import java.util.ArrayList;
import java.util.List;

import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class LogonActivity extends Activity {

    private final String TAG = this.getClass().getSimpleName();

    private EditText edtAccount;
    private EditText edtPassword;

    private Button btnLogon;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.logon);

        edtAccount = (EditText) this.findViewById(R.id.edtAccount);
        edtPassword = (EditText) this.findViewById(R.id.edtPassword);

        btnLogon = (Button) this.findViewById(R.id.btnLogon);

        setButtonOnClick();
    }

    private void setButtonOnClick() {
        this.btnLogon.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {

                    private ProgressDialog progressDialog;

                    @Override
                    protected void onPostExecute(String result) {
                        // TODO Auto-generated method stub
                        // super.onPostExecute(result);
                        progressDialog.cancel();
                        Log.d(TAG, result);
                        try {
                            JSONObject json = new JSONObject(result);
                            String msg = json.getString("Result");
                            // 是否登录
                            if (json.getBoolean("IsSuccess")) {
                                Toast.makeText(LogonActivity.this, msg,
                                        Toast.LENGTH_SHORT).show();

                                // 跳转登录Activity
                                Intent intent = new Intent();
                                intent.setClass(LogonActivity.this,
                                        MainActivity.class);
                                LogonActivity.this.startActivity(intent);
                            } else {
                                Toast.makeText(LogonActivity.this, msg,
                                        Toast.LENGTH_SHORT).show();
                            }
                        } catch (JSONException e) {
                            // TODO Auto-generated catch block
                            Log.e(TAG, e.toString());
                        }
                    }

                    @Override
                    protected void onPreExecute() {
                        // TODO Auto-generated method stub
                        super.onPreExecute();
                        progressDialog = new ProgressDialog(LogonActivity.this);
                        progressDialog.setCancelable(false);
                        progressDialog
                                .setProgressStyle(ProgressDialog.STYLE_SPINNER);
                        progressDialog.setTitle("登录中，请稍后...");
                        progressDialog.show();
                    }

                    @Override
                    protected String doInBackground(Void... arg0) {
                        // TODO Auto-generated method stub
                        String account = edtAccount.getText().toString();
                        String password = edtPassword.getText().toString();
                        List<NameValuePair> params = new ArrayList<NameValuePair>();
                        params.add(new BasicNameValuePair("account", account));
                        params.add(new BasicNameValuePair("password", password));

                        try {
                            return HttpHelper.invoke("Register", params);
                        } catch (Exception e) {
                            Log.e(TAG, e.toString());
                            return null;
                        }
                    }
                };
                task.execute();
            }
        });
    }
}

package ld.com.authorize;

import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {

    private final String TAG = this.getClass().getSimpleName();

    private Button btnInvoke;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnInvoke = (Button) this.findViewById(R.id.btnInvoke);

        setInvokeOnClick();
    }

    private void setInvokeOnClick() {
        btnInvoke.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {

                    private ProgressDialog progressDialog;

                    @Override
                    protected void onPostExecute(String result) {
                        // TODO Auto-generated method stub
                        // super.onPostExecute(result);
                        progressDialog.cancel();
                        Log.d(TAG, result);
                        try {
                            JSONObject json = new JSONObject(result);
                            // 是否登录
                            if (json.getBoolean("IsAuthenticated")) {
                                String msg = json.getString("Identity") + ":"
                                        + json.getString("Result");
                                Toast.makeText(MainActivity.this, msg,
                                        Toast.LENGTH_SHORT).show();
                            } else {
                                Toast.makeText(MainActivity.this,
                                        json.getString("Result"),
                                        Toast.LENGTH_SHORT).show();

                                // 跳转登录Activity
                                Intent intent = new Intent();
                                intent.setClass(MainActivity.this,
                                        LogonActivity.class);
                                MainActivity.this.startActivity(intent);
                            }
                        } catch (JSONException e) {
                            // TODO Auto-generated catch block
                            Log.e(TAG, e.toString());
                        }
                    }

                    @Override
                    protected void onPreExecute() {
                        // TODO Auto-generated method stub
                        super.onPreExecute();
                        progressDialog = new ProgressDialog(MainActivity.this);
                        progressDialog.setCancelable(false);
                        progressDialog
                                .setProgressStyle(ProgressDialog.STYLE_SPINNER);
                        progressDialog.setTitle("调用中，请稍后...");
                        progressDialog.show();
                    }

                    @Override
                    protected String doInBackground(Void... arg0) {
                        // TODO Auto-generated method stub
                        try {
                            return HttpHelper.invoke("Index");
                        } catch (Exception e) {
                            Log.e(TAG, e.toString());
                            return null;
                        }
                    }

                };
                task.execute();
            }
        });
    }
}

最后，设置访问权限：<uses-permission android:name="android.permission.INTERNET" />

四、运行结果

1.进入主MainActivity，图4.1.1所示。

图4.1.1

2.调用Http请求，图4.2.1所示。

图4.2.1

3.由于没有登陆，所以跳转到登陆Activity，图4.3.1所示。

图4.3.1

4.故意输入错误密码使其登陆失败，图4.4.1所示。

图4.4.1

5.输入正确的密码后跳转到主Activity，如图4.5.1所示。

图4.5.1

6.再一次调用Http请求，这次是已登陆状态，图4.6.1所示。

图4.6.1

代码下载

作者：刘冬.NET

出处：http://www.cnblogs.com/GoodHelper/archive/2011/08/19/android_iis_02.html

欢迎转载，但须保留版权。

本文链接

Android与IIS身份验证——基本验证

2011-08-17T11:34:00Z

内容摘要

前言

1.服务器端

2.Android客户端

3.IIS部署

4.运行效果

在Android移动项目开发中，访问服务器时,为了简洁方便，我们经常使用http协议来传递JSON格式的数据。然而有些项目需要有一定的安全性，如使用Android客户端登陆到MIS系统。虽然我们是通过Android手机客户端的登陆Activity中登陆到系统的，但是略懂电脑的黑客是能够跳过登陆Activity，从而直接进入系统的。这样，会造成一些由于系统的不安全所带来的麻烦。建立一种防止黑客强行登录的身份验证模式尤为重要。此时，系统的身份验证成为阻挡黑客登陆的一道屏障。那么，怎样实现一个身份验证呢？让我们以IIS为宿主，一步一步的实现身份验证吧。

一、ASP.NET服务器端

首先，我们使用VS2010创建一个web项目(可以是WebForms，也可以是MVC，我这里使用的是ASP.NET MVC项目)。图1.1所示

图1.1

然后，在HomeController的Index Action中输入：登陆成功。

    [HandleError]
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return Content("登陆成功");
        }
    }

二、Android客户端

首先，创建一个Android项目，并新建一个MainActivity类。

接着，编写一个访问IIS服务器的类。

package ld.com.authorize;

import java.io.BufferedReader;
import java.io.InputStreamReader;

import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.DefaultHttpClient;

import android.util.Log;

public abstract class HttpHelper {

    private final static String TAG = "HttpHelper";

    public static String invoke() {
        String result = null;
        try {
             final String url = "http://192.168.1.104:180/";

            HttpPost httpPost = new HttpPost(url);
            DefaultHttpClient httpClient = new DefaultHttpClient();

            //基本身份验证
            BasicCredentialsProvider bcp = new BasicCredentialsProvider();
            String userName = "liudong";
            String password = "123";
            bcp.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(
                    userName, password));
            httpClient.setCredentialsProvider(bcp);

            HttpResponse httpResponse = httpClient.execute(httpPost);

            StringBuilder builder = new StringBuilder();
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    httpResponse.getEntity().getContent()));
            for (String s = reader.readLine(); s != null; s = reader.readLine()) {
                builder.append(s);
            }
            result = builder.toString();
            Log.d(TAG, "result is ( " + result + " )");
        } catch (Exception e) {
            Log.e(TAG, e.toString());
        }
        Log.d(TAG, "over");
        return result;
    }
}

注意的是，我这里用户名和密码分别是：liudong和123。

然后，修改layout文件：main.xml

最后，修改MainActivity。

package ld.com.authorize;

import android.app.Activity;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {

    private final String TAG = this.getClass().getSimpleName();

    private Button btnPassword;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btnPassword = (Button) this.findViewById(R.id.btnPassword);

        setInvokeOnClick();
    }

    private void setInvokeOnClick() {
        btnPassword.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                AsyncTask<Void, Void, String> task = new AsyncTask<Void, Void, String>() {

                    private ProgressDialog progressDialog;

                    @Override
                    protected void onPostExecute(String result) {
                        // TODO Auto-generated method stub
                        // super.onPostExecute(result);
                        progressDialog.cancel();
                        Toast.makeText(MainActivity.this, result,
                                Toast.LENGTH_SHORT).show();

                        Log.d(TAG, result);
                    }

                    @Override
                    protected void onPreExecute() {
                        // TODO Auto-generated method stub
                        super.onPreExecute();
                        progressDialog = new ProgressDialog(MainActivity.this);
                        progressDialog
                                .setProgressStyle(ProgressDialog.STYLE_SPINNER);
                        progressDialog.setTitle("调用中，请稍后...");
                        progressDialog.show();
                    }

                    @Override
                    protected String doInBackground(Void... arg0) {
                        // TODO Auto-generated method stub
                        try {
                            return HttpHelper.invoke();
                        } catch (Exception e) {
                            return null;
                        }
                    }

                };
                task.execute();
            }
        });
    }
}

设置访问权限为：<uses-permission android:name="android.permission.INTERNET" />

运行模拟器的效果如图2.1所示。

图2.1

三、IIS部署

首先、添加一个网站，如图3.1所示。

如图3.1

接着，在进入计算机管理-->本地用户和组-->用户，新建一个用户，如图3.2所示。

图3.2

然后，设置IIS的身份验证(图3.3所示)。

图3.3

设置其身份验证模式为：基本验证或Window身份s验证(图3.4所示)。

图3.4

最后，我们在浏览器中输入网址进行验证，验证结果见图3.5和图3.6。

图3.5

图3.6

从图中我们可以发现，浏览该网页时需要用户名和密码。我们输入了正确的用户名和密码后就可以登录这个页面了。

四，运行效果。

见图4.1和图4.2所示。

图4.1

图4.2

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/08/17/android_iis_01.html

作者：刘冬.NET

欢迎转载，但须保留版权。

本文链接

以C#编写的Socket服务器的Android手机聊天室Demo

2011-07-07T18:26:00Z

内容摘要

1.程序架构

2.通信协议

3.服务器源代码

4.客户端源代码

5.运行效果

一、程序架构

在开发一个聊天室程序时，我们可以使用Socket、Remoting、WCF这些具有双向通信的协议或框架。而现在，我正要实现一个C#语言作为服务器端、Android作为客户端的聊天室。由于服务器端和客户端不是同一语言(C#和java)，所有我选择了Socket作为通信协议。

图1.1所示，我们可以看出：android手机客户端A向服务器端发送消息，服务器端收到消息后，又把消息推送到android手机客户端B。

图1.1

二、通信协议

我们知道，在C#语言中使用Socket技术需要“四部曲”，即“Bind”，“Listen”，“Accept”，“Receive”。然而Socket编程不像WCF那样面向对象。而且对应每个请求都用同一种方式处理。作为习惯面向对象编程的我来说，编写一个传统的Socket程序很不爽。绞尽脑汁，我们将数据传输的格式改为json(JavaScript Object Notation 是一种轻量级的数据交换格式)，面对对象的问题就解决了。

假设程序的服务契约有两个方法：“登陆”和“发送消息”。调用登陆的方法，就传送方法名(Method Name)为“Logon”的json数据；调用发送消息的方法，就传送方法名为“Send”的json数据。返回的数据中也使用json格式，这样在android客户端中也能知道是哪个方法的返回值了。

三、服务器源代码

首先需要编写一个处理客户端消息的接口：IResponseManager。

    public interface IResponseManager
    {
        void Write(Socket sender, IList<Socket> cliens, IDictionary<string, object> param);
    }

其次，我们知道，换了是WCF编程的话，就需要在服务契约中写两个方法：“登陆”和“发送消息”。由于这里是Socket编程，我们实现之前写的IResponseManager接口，一个实现作为“登陆”的方法，另一个实现作为“发送消息”的方法。

public class LogonResponseManager : IResponseManager
    {
        public void Write(System.Net.Sockets.Socket sender, IList<System.Net.Sockets.Socket> cliens, IDictionary<string, object> param)
        {
            Console.WriteLine("客户端({0})登陆", sender.Handle);
            var response = new SocketResponse
            {
                Method = "Logon",
                DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                Result = new { UserName = param["UserName"].ToString() }
            };

            JavaScriptSerializer jss = new JavaScriptSerializer();
            string context = jss.Serialize(response);
            Console.WriteLine("登陆发送的数据为:{0}", context);
            sender.Send(Encoding.UTF8.GetBytes(context + "\n"));
        }
    }

public class SendResponseManager : IResponseManager
    {
        public void Write(System.Net.Sockets.Socket sender, IList<System.Net.Sockets.Socket> cliens, IDictionary<string, object> param)
        {
            Console.WriteLine("客户端({0})发送消息", sender.Handle);
            var msgList = param["Message"] as IEnumerable<object>;
            if (msgList == null)
            {
                return;
            }

            var response = new SocketResponse
            {
                Method = "Send",
                DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                Result = new
                {
                    UserName = param["UserName"].ToString(),
                    Message = msgList.Select(s => s.ToString()).ToArray()
                }
            };

            JavaScriptSerializer jss = new JavaScriptSerializer();
            string context = jss.Serialize(response);
            Console.WriteLine("消息发送的数据为:{0}", context);

            Parallel.ForEach(cliens, (item) =>
            {
                try
                {
                    item.Send(Encoding.UTF8.GetBytes(context + "\n"));
                }
                catch { };
            });
        }
    }

最后在Socket程序中使用反射加“策略模式”调用这两个接口实现类。

            var typeName = "SocketServer." + request.Method + "ResponseManager, SocketServer";
            Console.WriteLine("反射类名为：" + typeName);

            Type type = Type.GetType(typeName);
            if (type == null)
            {
                return;
            }

            var manager = Activator.CreateInstance(type) as IResponseManager;
            manager.Write(sender, this.socketClientSesson.Select(s => s.Key).ToList(),
                request.Param as IDictionary<string, object>);

完整的Socket服务器代码如下：

public class SocketHost
    {
        private IDictionary<Socket, byte[]> socketClientSesson = new Dictionary<Socket, byte[]>();

        public int Port { get; set; }

        public void Start()
        {
            var socketThread = new Thread(() =>
            {
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint iep = new IPEndPoint(IPAddress.Any, this.Port);

                //绑定到通道上
                socket.Bind(iep);

                //侦听
                socket.Listen(6);

                //通过异步来处理
                socket.BeginAccept(new AsyncCallback(Accept), socket);

            });

            socketThread.Start();

            Console.WriteLine("服务器已启动");
        }

        private void Accept(IAsyncResult ia)
        {
            Socket socket = ia.AsyncState as Socket;
            var client = socket.EndAccept(ia);

            socket.BeginAccept(new AsyncCallback(Accept), socket);

            byte[] buf = new byte[1024];
            this.socketClientSesson.Add(client, buf);

            try
            {
                client.BeginReceive(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(Receive), client);
                string sessionId = client.Handle.ToString();
                Console.WriteLine("客户端({0})已连接", sessionId);
            }
            catch (Exception ex)
            {
                Console.WriteLine("监听请求时出错：\r\n" + ex.ToString());
            }
        }

        private void Receive(IAsyncResult ia)
        {
            var client = ia.AsyncState as Socket;

            if (client == null || !this.socketClientSesson.ContainsKey(client))
            {
                return;
            }

            int count = client.EndReceive(ia);

            byte[] buf = this.socketClientSesson[client];

            if (count > 0)
            {
                try
                {
                    client.BeginReceive(buf, 0, buf.Length, SocketFlags.None, new AsyncCallback(Receive), client);
                    string context = Encoding.UTF8.GetString(buf, 0, count);
                    Console.WriteLine("接收的数据为:", context);

                    this.Response(client, context);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("接收的数据出错:\r\n{0}", ex.ToString());
                }
            }
            else
            {
                try
                {
                    string sessionId = client.Handle.ToString();
                    client.Disconnect(true);
                    this.socketClientSesson.Remove(client);
                    Console.WriteLine("客户端({0})已断开", sessionId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("客户端已断开出错" + ex.ToString());
                }
            }
        }

        private void Response(Socket sender, string context)
        {
            SocketRequest request = null;
            JavaScriptSerializer jss = new JavaScriptSerializer();
            request = jss.Deserialize(context, typeof(SocketRequest)) as SocketRequest;

            if (request == null)
            {
                return;
            }

            var typeName = "SocketServer." + request.Method + "ResponseManager, SocketServer";
            Console.WriteLine("反射类名为：" + typeName);

            Type type = Type.GetType(typeName);
            if (type == null)
            {
                return;
            }

            var manager = Activator.CreateInstance(type) as IResponseManager;
            manager.Write(sender, this.socketClientSesson.Select(s => s.Key).ToList(),
                request.Param as IDictionary<string, object>);
        }
    }

最后，json数据传输的实体对象为：

   [Serializable]
    public class SocketRequest
    {
        public string Method { get; set; }

        public string DateTime { get; set; }

        public object Param { get; set; }
    }

    [Serializable]
    public class SocketResponse
    {
        public string Method { get; set; }

        public string DateTime { get; set; }

        public object Result { get; set; }
    }

四、客户端源代码

1.布局文件

logon.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="fill_parent"
    android:layout_height="fill_parent" android:background="@drawable/background">

    <LinearLayout android:orientation="vertical"
        android:layout_width="fill_parent" android:layout_height="60dip"
        android:background="@drawable/logon" />

    <LinearLayout android:orientation="vertical"
        android:layout_width="fill_parent" android:layout_height="fill_parent"
        android:paddingLeft="10dp" android:paddingRight="10dp">

        <View android:layout_width="fill_parent" android:layout_height="20dip" />

        <TextView android:id="@+id/feedback_title" android:textColor="#FFFFFF"
            android:layout_width="fill_parent" android:layout_height="wrap_content"
            android:text="用户名：" />
        <EditText android:id="@+id/edtUserName" android:layout_width="fill_parent"
            android:layout_height="wrap_content" />

        <View android:layout_width="fill_parent" android:layout_height="2dip"
            android:background="#FF909090" />

        <TextView android:layout_width="fill_parent"
            android:textColor="#FFFFFF" android:layout_height="wrap_content"
            android:text="IP地址：" />
        <EditText android:id="@+id/edtIp" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:digits="1234567890."
            android:text="192.168.1.101"/>

        <View android:layout_width="fill_parent" android:layout_height="2dip"
            android:background="#FF909090" />

        <TextView android:layout_width="fill_parent"
            android:textColor="#FFFFFF" android:layout_height="wrap_content"
            android:text="端口号：" />
        <EditText android:id="@+id/edtPort" android:layout_width="fill_parent"
            android:layout_height="wrap_content" android:inputType="number"
            android:numeric="integer" android:text="1234"/>

        <LinearLayout android:orientation="horizontal"
            android:layout_width="fill_parent" android:layout_height="wrap_content"
            android:layout_marginTop="10dp">
        </LinearLayout>
        <RelativeLayout android:layout_width="fill_parent"
            android:layout_height="fill_parent">
            <View android:id="@+id/feedback_content" android:layout_width="fill_parent"
                android:layout_height="fill_parent" android:maxEms="10"
                android:minEms="10" android:gravity="top"
                android:layout_marginBottom="50dip" />
            <Button android:id="@+id/btnLogon" android:layout_width="fill_parent"
                android:layout_height="50dp" android:text="登陆" android:textSize="19dp"
                android:layout_gravity="center_horizontal"
                android:layout_alignParentBottom="true" />
        </RelativeLayout>
    </LinearLayout>
</LinearLayout>

main.xml：

listview_item.xml：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="wrap_content"
    android:orientation="vertical" android:paddingBottom="3dip"
    android:paddingLeft="10dip">

    <TextView android:layout_height="wrap_content"
        android:layout_width="fill_parent" android:id="@+id/itmMessage"
        android:textSize="20dip">
    </TextView>

    <LinearLayout android:layout_width="fill_parent"
        android:orientation="horizontal" android:layout_height="20dip">
        <TextView android:layout_height="fill_parent"
            android:layout_width="100dip" android:id="@+id/itmUserName" >
        </TextView>

        <TextView android:layout_height="fill_parent"
            android:layout_width="200dip" android:id="@+id/itmTime" >
        </TextView>

    </LinearLayout>

</LinearLayout>

SocketClient：

package ld.socket;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class SocketClient {

    private static Socket client;

    private static SocketClient instance = null;

    public static SocketClient getInstance() {
        if (instance == null) {

            synchronized (ChartInfo.class) {
                if (instance == null) {
                    try {
                        ChartInfo chartInfo = ChartInfo.getInstance();
                        client = new Socket(chartInfo.getIp(), chartInfo
                                .getPort());
                        instance = new SocketClient();
                    } catch (UnknownHostException e) {
                        // TODO Auto-generated catch block
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                    }
                }
            }
        }
        return instance;
    }

    private SocketClient() {
        this.initMap();
        this.startThread();
    }

    private void initMap() {
        this.handlerMap = new HashMap<String, Handler>();
    }

    public void close() {
        try {
            client.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            //e.printStackTrace();
        }
        instance = null;
    }

    private void startThread() {
        Thread thread = new Thread() {
            @Override
            public void run() {

                while (true) {
                    if (client == null || !client.isConnected()) {
                        continue;
                    }

                    BufferedReader reader;
                    try {
                        reader = new BufferedReader(new InputStreamReader(
                                client.getInputStream()));
                        String line = reader.readLine();
                        Log.d("initSocket", "line:" + line);
                        if (line.equals("")) {
                            continue;
                        }

                        JSONObject json = new JSONObject(line);
                        String method = json.getString("Method");
                        Log.d("initSocket", "method:" + method);
                        if (method.equals("")
                                || !handlerMap.containsKey(method)) {
                            Log.d("initSocket", "handlerMap not method");
                            continue;
                        }

                        Handler handler = handlerMap.get(method);
                        if (handler == null) {
                            Log.d("initSocket", "handler is null");
                            continue;
                        }
                        Log.d("initSocket", "handler:" + method);
                        Object obj = json.getJSONObject("Result");
                        Log.d("initSocket", "Result:" + obj);
                        Message msg = new Message();
                        msg.obj = obj;
                        handler.sendMessage(msg);

                    } catch (IOException e) {

                    } catch (JSONException e) {

                    }
                }
            }
        };
        thread.start();
    }

    private Map<String, Handler> handlerMap;

    public void putHandler(String methodnName, Handler handler) {
        this.removeHandler(methodnName);
        this.handlerMap.put(methodnName, handler);
    }

    public void removeHandler(String methodnName) {
        if (this.handlerMap.containsKey(methodnName)) {
            this.handlerMap.remove(methodnName);
        }
    }

    public void logon(String userName) {
        Log.d("initSocket", "logon");
        try {
            OutputStreamWriter osw = new OutputStreamWriter(client
                    .getOutputStream());

            BufferedWriter writer = new BufferedWriter(osw);

            JSONObject param = new JSONObject();
            param.put("UserName", userName.replace("\n", " "));

            JSONObject json = this.getJSONData("Logon", param);

            writer.write(json.toString());
            writer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void sendMessage(String message) {
        Log.d("initSocket", "Send");
        try {
            OutputStreamWriter osw = new OutputStreamWriter(client
                    .getOutputStream());

            BufferedWriter writer = new BufferedWriter(osw);

            JSONArray array = new JSONArray();
            for (String item : message.split("\n")) {
                array.put(item);
            }

            JSONObject param = new JSONObject();
            param.put("Message", array);

            param.put("UserName", ChartInfo.getInstance().getUserName());

            JSONObject json = this.getJSONData("Send", param);

            writer.write(json.toString());
            writer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JSONException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private JSONObject getJSONData(String methodName, JSONObject param) {
        JSONObject json = new JSONObject();
        try {
            json.put("Method", methodName);
            SimpleDateFormat format = new SimpleDateFormat(
                    "yyyy-MM-dd HH:mm:ss");
            json.put("DateTime", format.format(new Date()));
            json.put("Param", param);
            return json;
        } catch (JSONException e) {
            return null;
        }
    }
}

LogonActivity：

package ld.socket;

import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class LogonActivity extends Activity {

    private EditText edtUserName;
    private EditText edtIp;
    private EditText edtPort;

    private Button btnLogon;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);

        setContentView(R.layout.logon);

        this.initViews();
    }

    private void initViews() {
        this.edtUserName = (EditText) this.findViewById(R.id.edtUserName);
        this.edtIp = (EditText) this.findViewById(R.id.edtIp);
        this.edtPort = (EditText) this.findViewById(R.id.edtPort);

        this.btnLogon = (Button) this.findViewById(R.id.btnLogon);
        this.btnLogon.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                // showAlert(edtUserName.getText().toString());
                if (edtUserName.getText().toString().equals("")) {
                    showDialog("请输入用户名");
                    return;
                }

                if (edtIp.getText().toString().equals("")) {
                    showDialog("请输入IP地址");
                    return;
                }

                if (edtPort.getText().toString().equals("")) {
                    showDialog("请输入端口号");
                    return;
                }

                int port = Integer.parseInt(edtPort.getText().toString());
                ChartInfo chartInfo = ChartInfo.getInstance();
                chartInfo.setIp(edtIp.getText().toString());
                chartInfo.setPort(port);
                SocketClient proxy = SocketClient.getInstance();

                if (proxy == null) {
                    showDialog("未接入互联网");
                    setWireless();
                    return;
                }

                proxy.putHandler("Logon", new Handler() {
                    @Override
                    public void handleMessage(Message msg) {

                        SocketClient proxy = SocketClient.getInstance();
                        proxy.removeHandler("Logon");
                        Log.d("initSocket", "handleMessage");
                        if (msg == null || msg.obj == null) {
                            return;
                        }

                        JSONObject json = (JSONObject) msg.obj;
                        try {
                            String userName = json.getString("UserName");
                            Log.d("initSocket", "userName:" + userName);
                            ChartInfo.getInstance().setUserName(userName);
                            Intent itt = new Intent();
                            itt
                                    .setClass(LogonActivity.this,
                                            MainActivity.class);
                            LogonActivity.this.startActivity(itt);
                        } catch (JSONException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                });
                proxy.logon(edtUserName.getText().toString());
            }
        });
    }

    private void setWireless() {
        Intent mIntent = new Intent("/");
        ComponentName comp = new ComponentName("com.android.settings",
                "com.android.settings.WirelessSettings");
        mIntent.setComponent(comp);
        mIntent.setAction("android.intent.action.VIEW");
        startActivityForResult(mIntent, 0);
    }

    private void showDialog(String mess) {
        new AlertDialog.Builder(this).setTitle("信息").setMessage(mess)
                .setNegativeButton("确定", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                    }
                }).show();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

            AlertDialog alertDialog = new AlertDialog.Builder(
                    LogonActivity.this).setTitle("退出程序").setMessage("是否退出程序")
                    .setPositiveButton("确定",
                            new DialogInterface.OnClickListener() {

                                public void onClick(DialogInterface dialog,
                                        int which) {
                                    LogonActivity.this.finish();
                                }

                            }).setNegativeButton("取消",

                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            return;
                        }
                    }).create(); // 创建对话框

            alertDialog.show(); // 显示对话框

            return false;

        }

        return false;
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        SocketClient proxy = SocketClient.getInstance();
        if (proxy != null) {
            proxy.close();
        }
    }

}

MainActivity：

package ld.socket;

import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.WindowManager;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;

public class MainActivity extends Activity {

    private EditText edtMessage;

    private Button btnSend;

    private ListView ltvMessage;

    private MessageAdapter adapter;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // 隐藏键盘
        this.getWindow().setSoftInputMode(
                WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

        Log.d("initSocket", "MessageAdapter");
        this.adapter = new MessageAdapter(this);
        Log.d("initSocket", "adapter is ok");

        this.findThisViews();
        this.initHandler();

        this.serOnClick();

        Log.d("initSocket", "onCreate");
    }

    private void findThisViews() {
        this.edtMessage = (EditText) this.findViewById(R.id.edtMessage);
        this.btnSend = (Button) this.findViewById(R.id.btnSend);

        this.ltvMessage = (ListView) this.findViewById(R.id.ltvMessage);
        // this.ltvMessage.setEnabled(false);
        this.ltvMessage.setAdapter(this.adapter);
    }

    private void initHandler() {

        Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                if (msg.obj == null) {
                    Log.d("initSocket", "handleMessage is null");
                    return;
                }

                Log.d("initSocket", "handleMessage");
                try {
                    JSONObject json = (JSONObject) msg.obj;
                    String userName = json.getString("UserName");

                    StringBuilder sb = new StringBuilder();
                    int length = json.getJSONArray("Message").length();
                    for (int i = 0; i < length; i++) {
                        String item = json.getJSONArray("Message").getString(i);
                        if (item.equals("")) {
                            continue;
                        }
                        if (length > i + 1) {
                            Log.d("initSocket", "length:" + length);
                            Log.d("initSocket", "i:" + i);
                            Log.d("initSocket", "item:" + item);
                            item += "\n";
                        }
                        sb.append(item);
                    }

                    MessageRecord record = new MessageRecord();
                    record.setUserName(userName);
                    record.setMessage(sb.toString());

                    MainActivity.this.adapter.add(record);
                    adapter.notifyDataSetChanged();
                } catch (JSONException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        };
        SocketClient proxy = SocketClient.getInstance();
        proxy.putHandler("Send", handler);
    }

    private void serOnClick() {
        this.btnSend.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                btnSend.setEnabled(false);
                String txt = edtMessage.getText().toString();
                if (txt.equals("")) {
                    btnSend.setEnabled(true);
                    return;
                }
                SocketClient proxy = SocketClient.getInstance();
                proxy.sendMessage(txt);
                edtMessage.setText("");
                btnSend.setEnabled(true);
            }
        });
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

            AlertDialog alertDialog = new AlertDialog.Builder(
                    MainActivity.this).setTitle("询问").setMessage("是否注销登录？")
                    .setPositiveButton("确定",
                            new DialogInterface.OnClickListener() {

                                public void onClick(DialogInterface dialog,
                                        int which) {
                                    MainActivity.this.finish();
                                }

                            }).setNegativeButton("取消",

                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int which) {
                            return;
                        }
                    }).create(); // 创建对话框

            alertDialog.show(); // 显示对话框

            return false;

        }

        return false;
    }
}

五、运行效果

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/07/08/android_socket_chart.html

欢迎转载，但需保留版权！

本文链接

NHibernate从入门到精通系列(10)——多对多关联映射

2011-03-03T16:26:00Z

内容摘要

单向多对多关联映射

双向多对多关联映射

一、单向多对多关联映射

1.1 多对多关联映射描述

众所周知，持久化类的有三种对应关系：“一对一”、“一对多（多对一）”和“多对多”。在项目开发过程中，我们接触过权限系统。而权限系统中，“用户”和“角色”的对应关系往往就是“多对多”。

让我们看一下“多对多”的数据，如图1.1.1所示：

图1.1.1

从数据中，我们能够观察到：多个用户(User)对应多个角色(Role)。构造“多对多”的关联关系，我们不仅需要用户(User)表和角色(Role)表，还需要用户和角色的关系表。通过这三张表的关系构造了“多对多”的关联关系。

让我们看一下代码：

    public class Role
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }
    }

    public class User
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual IList<Role> Roles { get; set; }
    }

映射文件：

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Role" table="T_Role" lazy="true" >
    <id name="ID" type="int" column="RoleID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

  </class>
</hibernate-mapping>

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="User" table="T_User" lazy="true" >
    <id name="ID" type="int" column="UserID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

    <bag name="Roles" table="T_User_Role">
      <key column="UserID"/>
      <many-to-many class="Role" column="RoleID"/>
    </bag>

  </class>
</hibernate-mapping>

在用户(User)类中有与角色(Role)对应的IList<Role>属性Roles，在映射文件中我们用<bag>和<many-to-many>标签描述“多对多”关联映射。

其中，<bag>标签中的“table”属性是设置“多对多”映射的第三方的关系表。注意的是“T_User_Role”这个第三方关系表不在持久化类的结构中体现。<key>标签的“column”属性用于指定主键表的主键，<many-to-many>标签的“column”属性用于指定外键表的关联字段。

1.2 单向多对多关联映射的数据插入

我们编写单元测试类的代码：

    [TestFixture]
    public class ManyToManyTest
    {
        private ISessionFactory sessionFactory;

        public ManyToManyTest()
        {
            log4net.Config.XmlConfigurator.Configure();
        }

        [SetUp]
        public void Init()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure("Config/hibernate.cfg.xml");
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var role1 = new Role { Name = "库管" };
                var role2 = new Role { Name = "出纳" };
                var role3 = new Role { Name = "会计" };

                var liu = new User
                {
                    Name = "刘冬",
                    Roles = new List<Role> { role1, role2 }
                };
                var zhang = new User
                {
                    Name = "张三" ,
                    Roles = new List<Role> { role2, role3 }
                };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(role1);
                    session.Save(role2);
                    session.Save(role3);

                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }
}

运行效果如图1.2.1所示，运行成功。

图1.2.1　

首先生成了主表的“insert into”语句，其次生成关系表的“insert into”语句。

二、双向多对多关联映射

2.1 双向多对多关联映射的描述

实现双向多对多关联映射需要修改一下代码和映射文件：

    public class Role
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual IList<User> Users { get; set; }
    }

在角色(Role)类中建立用户(User)的IList<User>属性“Users”。这样，多个角色(Role)对应多个用户(User)，多个用户(User)也对应多个角色(Role)。

2.2 双向多对多关联映射的数据插入

编写单元测试代码：

        [Test]
        public void SaveRoleTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var user = new User
                {
                    Name = "刘冬"
                };

                var role = new Role
                {
                    Name = "系统管理员",
                    Users = new List<User> { user }
                };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(user);
                    session.Save(role);

                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图2.2.1所示，运行成功

图2.2.1

设置cascade属性为all，用于从一端保存数据。

        [Test]
        public void SaveUserTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var role = new Role
                {
                    Name = "系统管理员",
                };

                var user = new User
                {
                    Name = "刘冬",
                    Roles = new List<Role> { role }
                };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(user);

                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图2.2.2所示，运行成功。

图2.2.2

我们设置<bag>标签的inverse为true：

运行效果如图2.2.3所示，虽然运行成功，但没有将数据插入关系表“T_User_Role”。

图2.2.3

这是为什么呢？因为“inverse”属性的意思是反转，就是将操作权交给关联关系的另一点，“多对多”关联映射的另一端始终是它们的“关系表”。正因为“关系表”不在持久化类中体现，所以在“多对多”关联映射中设置“inverse”属性是没有意义的。

2.3 双向多对多关联映射的数据更新

我们编写单元测试的代码：

        [Test]
        public void UpdateUserTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {

                var role = new Role
                {
                    Name = "系统管理员",
                };

                var user = session.Get<User>(1);
                user.Roles.Clear();
                user.Roles.Add(role);

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Update(user);

                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图2.3.1所示，运行成功。生成了“delete”语句，删除了原有集合的数据，然后插入了新的集合数据。

图2.3.1

2.4 双向多对多关联映射的数据查询

编写单元测试类代码：

        [Test]
        public void SelectTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var user = session.Get<User>(1);

                foreach (var item in user.Roles)
                {
                    Console.WriteLine("角色名称：{0}", item.Name);
                    foreach (var us in item.Users)
                    {
                        Console.WriteLine("用户名称：{0}", us.Name);
                    }
                }
            }
        }

运行效果如图2.4.1所示，运行成功。

图2.4.1

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/03/04/nhibernate10.html

欢迎转载，但需保留版权。

本文链接

NHibernate从入门到精通系列(9)——一对多关联映射

2011-03-03T07:36:00Z

内容摘要

　　单向关联映射

双向关联映射

一、单向关联映射

1.1 单向关联映射的描述

让我们回顾一下之前讲的《多对一关联映射》，如图1.1.1所示，其实“一对多”关联映射就是“多对一”关联映射相反的映射。

图1.1.1

至于“一对多”单向关联映射的代码如下：

    public class Student
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }
    }

    public class Class
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual IList<Student> Students { get; set; }
    }

映射文件如下：

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Student" table="T_Student" lazy="true" >
    <id name="ID" type="int" column="StudentID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

  </class>
</hibernate-mapping>

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Class" table="T_Class" lazy="true" >
    <id name="ID" type="int" column="ClassID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

    <bag name="Students">
      <key column="ClassID"/>
      <one-to-many class="Student"/>
    </bag>

  </class>
</hibernate-mapping>

我们看到“Class”类中，有名为“Students” 的属性，其类型是IList<Student>。在映射文件中，我们使用<bag>和<one-to-many>标签来描述“一对多”关联映射。

1.2 单向关联映射的数据插入

单元测试类的代码如下：

    [TestFixture]
    public class OneToManyTest
    {
        private ISessionFactory sessionFactory;

        public OneToManyTest()
        {
            log4net.Config.XmlConfigurator.Configure();
        }

        [SetUp]
        public void Init()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure("Config/hibernate.cfg.xml");
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var liu = new Student { Name = "刘冬" };
                var zhang = new Student { Name = "张三" };

                var cls = new Class { Name = "1班" };
                cls.Students = new List<Student> { liu, zhang };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(liu);
                    session.Save(zhang);

                    session.Save(cls);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }
}

我们配置log4net输出SQL语句：

<?xml version="1.0"?>
<configuration>
  <configSections>

    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
  </configSections>

  
  <log4net debug="true">
    <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender">
      <layout type="log4net.Layout.PatternLayout">
        <param name="ConversionPattern" value="%d [%t] %-5p %c [%x] - %m%n" />
      </layout>
    </appender>
    <root>
      <level value="ALL" />
      <appender-ref ref="RollingLogFileAppender" />
    </root>
  </log4net>

  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
  </startup>
</configuration>

运行效果如图1.2.1所示，先成“insert into”语句，然后生成“update”语句修改外键。

图1.2.1

从图1.2.1中，我们能够观察到，如果“一对多”的外键不允许空，就有可能插入不成功。

我们将映射文件稍作修改：

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Class" table="T_Class" lazy="true" >
    <id name="ID" type="int" column="ClassID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

    
    <bag name="Students">
      <key column="ClassID" not-null="true"/>
      <one-to-many class="Student"/>
    </bag>

  </class>
</hibernate-mapping>

运行效果如图1.2.2所示，抛出“ClassID”不允许插入NULL的异常。

图1.2.2

二、双向关联映射

2.1 双向关联映射的描述

我们修改一下代码，来实现“一对多”双向关联映射：

    public class Student
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual Class Class { get; set; }
    }

“一对多”双向关联映射指的是：在“一”的这端（“Class”类这端）包含“多”的属性（“Students”）；在“多”的这端包含“一”的属性（“Class”属性）。这样两个类构成的循环引用就是双向关联映射。

2.2 双向关联映射的数据插入

插入数据的代码如下：

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var liu = new Student { Name = "刘冬" };
                var zhang = new Student { Name = "张三" };

                var cls = new Class { Name = "1班" };
                cls.Students = new List<Student> { liu, zhang };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(cls);
                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图2.2.1所示，运行成功。

图2.2.1

修改“Student”的映射文件，将“Class”属性修改为不允许空：

运行效果如图2.2.1所示，抛出“not-null property references a null or transient value”的异常。

图2.2.1

我修改单元测试代码：

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var liu = new Student { Name = "刘冬" };
                var zhang = new Student { Name = "张三" };

                var cls = new Class { Name = "1班" };
                cls.Students = new List<Student> { liu, zhang };

                liu.Class = cls;
                zhang.Class = cls;

                ITransaction tran = session.BeginTransaction();
                try
                {
                    //先保存班级
                    session.Save(cls);

                    //后保存学生
                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果图2.2.2所示，运行成功。

图2.2.2

我们修改保存“Student”和“Class”实例的先后顺序：

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var liu = new Student { Name = "刘冬" };
                var zhang = new Student { Name = "张三" };

                var cls = new Class { Name = "1班" };
                cls.Students = new List<Student> { liu, zhang };

                liu.Class = cls;
                zhang.Class = cls;

                ITransaction tran = session.BeginTransaction();
                try
                {
                    //先保存学生
                    session.Save(liu);
                    session.Save(zhang);

                    //后保存班级
                    session.Save(cls);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果图2.2.3所示，同样抛出“not-null property references a null or transient value”的异常。

图2.2.3

我们修改一下“Class”的映射文件：

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Class" table="T_Class" lazy="true" >
    <id name="ID" type="int" column="ClassID">
      <generator class="native"/>
    </id>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

    
    <bag name="Students" inverse="true" cascade="all">
      <key column="ClassID" not-null="true"/>
      <one-to-many class="Student"/>
    </bag>

  </class>
</hibernate-mapping>

然后修改单元测试的代码：

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var liu = new Student { Name = "刘冬" };
                var zhang = new Student { Name = "张三" };

                var cls = new Class { Name = "1班" };
                cls.Students = new List<Student> { liu, zhang };

                liu.Class = cls;
                zhang.Class = cls;

                ITransaction tran = session.BeginTransaction();
                try
                {
                    //只保存班级
                    session.Save(cls);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图2.2.4所示，运行成功，并且没有生成“update”语句，只生成“insert into”语句。

图2.2.4

这样，保存“一”的这端(“Class”实例)，就能够将“一”得那端（“Student”）连带保存。其中映射文件中的“inverse”的属性是反转的意思，就是将操作交给双向关联关系中的另一端。

我们细观察到生成的SQL语句，只生成了“insert into”语句，这样，执行效率就变的高了。

2.3 双向关联映射的数据查询

编写单元测试的代码：

        [Test]
        public void SelectTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var cls = session.Get<Class>(1);

                foreach (var item in cls.Students)
                {
                    Console.WriteLine("学生名为：{0}", item.Name);
                    Console.WriteLine("班级名为：{0}", item.Class.Name);
                }
            }
        }

运行效果如图2.3.1所示，比较以往使用SQL语句编程的代码后，发现调用“一对多”关联映射的集合变得如此方便。

图2.3.1

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/03/03/nhibernate09.html

欢迎转载，但需保留版权。

本文链接

NHibernate从入门到精通系列(8)——一对一关联映射

2011-02-24T17:02:00Z

内容摘要

单向主键关联映射

双向主键关联映射

唯一外键关联映射

NHibernate的一对一关联映射有三种，单向主键关联映射、双向主键关联映射、唯一外键关联映射。

一、单向主键关联映射

我们模拟一个现实情况：学生（Student）和家庭（Family）的关系。在中国，目前实行计划生育，一个家庭只有一个孩子，孩子上学后就成为了学生。学生和家庭的关系可以认为是一对一的。

让我们看一下“一对一”的表结构,如图1.1所示：

图1.1

让我们看一下“一对一”的实体类和映射文件：

    public class Student
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }
    }

    public class Family
    {
        public virtual int? ID { get; set; }

        public virtual string Adress { get; set; }

        public virtual Student Student { get; set; }
    }

  <class name="Student" table="T_Student" lazy="true" >

    <id name="ID" column="StudentID" type="int">
      <generator class="native"/>
    </id>

    <property name="Name" type="string" length="50"/>

  </class>

  <class name="Family" table="T_Family" lazy="true" >

    <id name="ID" column="FamilyID" type="int">
      <generator class="foreign">
        <param name="property">Student</param>
      </generator>
    </id>

    <property name="Adress" type="string" length="200"/>

    <one-to-one name="Student" constrained="true"/>
  </class>

其中，我们设置了“Family”类的主键生成策略为：“foreign”，含义是通过外键查询到主键值。

param的name属性设置为property，值设置为“Student”，表示通过“Student”属性查询到主键值。

然后使用<one-to-one>标签来描述“一对一”关联映射，并设置constrained属性为true，来建立一个外键约束。

环境建立好了，生成的表结构，如图1.2所示，我们能够观察到“T_Family”表的“FamilyID”字段既是主键又是外键。

图1.2

我们编写单元测试类的代码测试一下插入和查询。

    [TestFixture]
    public class DomainTest
    {
        private ISessionFactory sessionFactory;

        [SetUp]
        public void InitTest()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure("Config/hibernate.cfg.xml");
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
        public void SaveFamilyTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var student = new Student { Name = "刘冬" };
                var family = new Family { Adress = "新疆乌鲁木齐市", Student = student };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(family);
                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

        [Test]
        public void SelectFamilyTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var family = session.CreateQuery("from Family").List<Family>().First();

                Console.WriteLine("家庭地址为：{0}", family.Adress);
                Console.WriteLine("学生姓名为：{0}", family.Student.Name);
            }
        }
    }

插入的运行效果如图1.3所示，运行成功。奇怪的是，“Family”引用了一个临时态(Transient)的实例“Student” ，但并没有抛出异常。

这是因为<one-to-one>默认的cascade为all，这样NHibernate自动帮助我们把临时态(Transient)的实例持久化到数据库中了。

图1.3

查询的运行效果如图1.4所示，通过关联的属性带出了想要的信息。

图1.4

二、双向主键关联映射

我们修改一下代码，来体现双向主键关联映射：在“Student”类中加入属性“Family”，这样“Student”中有“Family”，“Family”中也有“Student”的循环引用方式就描述了双向主键关联映射的实体类结构。

然后在“Student”的映射文件中加入“<one-to-one name="Family" class="Family"/>”。

    public class Student
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual Family Family { get; set; }
    }

然后编写一个查询的单元测试方法：

        [Test]
        public void SelecStudentTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var student = session.Get<Student>(1);

                Console.WriteLine("学生姓名为：{0}", student.Name);
                Console.WriteLine("家庭地址为：{0}", student.Family.Adress);
            }
        }

运行效果如图2.1所示。奇怪的是仅生成了一条SQL语句就将两个表中的数据获取出来了。这是因为“一对一”主键关联映射默认的抓取(fetch)策略是“join”。

图2.1

三、唯一外键关联映射

唯一外键关联映射是非主键字段的“一对一”关联。

我们模拟一种“一对一”情况：一个班级对应了一个班主任老师，一个班主任老师管理一个班级。代码如下：

    public class Class
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        /// <summary>
        /// 班主任老师
        /// </summary>
        public virtual Teacher Teacher { get; set; }
    }

    public class Teacher
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual Class Class { get; set; }
    }

我们在“Class”类中使用<many-to-one>标签，并设置unique属性为true。然后在“Teacher”类中使用<one-to-one>标签，并设置属性“Class”的property-ref指向“Teacher”。

最后编写一个单元测试方法：

[Test]
        public void SaveTeacherTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var teacher = new Teacher { Name = "刘冬" };
                var cls = new Class { Name = "1班", Teacher = teacher };
                teacher.Class = cls;

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(teacher);
                    session.Save(cls);

                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

运行效果如图3.1所有，运行成功。

图3.1

然后观察生成的表结构，如图3.2所示，生成了唯一外键。

图3.2

但注意的是：唯一外键关联映射实际上使用的是<many-to-one>标签，所有说默认的cascade是“none”，这样必须确保在没有引用临时态(Transient)的实例下才能持久化数据。

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/02/25/nhibernate08.html

欢迎转载，但需保留版权。

本文链接

NHibernate从入门到精通系列(7)——多对一关联映射

2011-02-24T03:12:00Z

内容摘要

多对一关联映射概括

多对一关联映射插入和查询

多对一关联映配置介绍

一、多对一关联映射概括

关联关系是实体类与实体类之间的结构关系，分别为“多对一”、“一对一”、“多对多”。然而“多对一”是怎样描述的呢？让我们参考图1.1所示：

图1.1　

学生表“T_Student”有两条记录，它们分别对应了班级表“T_Class”的主键值为“1”的同一条记录。所以这就是“多对一”的使用情景。

让我们看一下“多对一”持久化类的结构：

    public class Class
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }
    }

    public class Student
    {
        public virtual int? ID { get; set; }

        public virtual string Name { get; set; }

        public virtual Class Class { get; set; }
    }

在“Student”类中有类型为“Class”的属性，这就意味着在“Student”有一个与之对应的“Class”类。

再让我们看一下映射文件：

我在“Student”类的映射文件中发现了“many-to-one”节点，<many-to-one>标签是描述“多对一”的关联映射。

该标签的name属性是“多对一”的类名，column是外键字段名。

我们配置好映射文件后运行程序，生成的表结构如图1.2所示：

图1.2

发现NHibernate帮我们生成了一个外键。

二、多对一关联映射插入和查询

2.1 多对一关联映射插入

我们编写一个测试类，测试一下“多对一”关联映射的插入。

代码如下：

[TestFixture]
    public class NHibernateInit
    {
        private ISessionFactory sessionFactory;

        [SetUp]
        public void InitTest()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure("Config/hibernate.cfg.xml");
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
        public void Save()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var cls = new Class { Name = "1班" };

                var liu = new Student { Name = "刘冬", Class = cls };
                var zhang = new Student { Name = "张三", Class = cls };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }
    }

使用NUnit运行测试类。如图2.1.1所示，发现抛出“object references an unsaved transient instance - save the transient instance before flushing. Type: Domain.Class, Entity: Domain.Class”这样的异常。

图2.1.1

这个异常是怎么回事呢？持久化“Student”类的实例后，“Student”类的实例变为“持久态(Persistent)”，而“Class”类的实例还是临时态(Transient)，当持久化一个持久态的实例时，若该实例引用了一个临时态的实例，就会抛出这样的异常。

我们修改一下代码：

[Test]
        public void Save()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var cls = new Class { Name = "1班" };

                var liu = new Student { Name = "刘冬", Class = cls };
                var zhang = new Student { Name = "张三", Class = cls };

                ITransaction tran = session.BeginTransaction();
                try
                {
                    //持久化“Class”类
                    session.Save(cls);

                    session.Save(liu);
                    session.Save(zhang);

                    tran.Commit();
                }
                catch(Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
            }
        }

然后运行修改过的程序。如图2.1.2所示，运行成功。

图2.1.2

同理，我们也可以修改<many-to-one>标签中的cascade属性为“all”,这样就能实现同样的效果。设置cascade属性后，当持久态的实例引用临时态的实例时，NHibernate就会帮我们把这个临时态的实例自动持久化到数据库中。

2.2 多对一关联映射查询

我们编写一个查询方法，当获取到“Student”时，可以通过其“Class”属性读取“Class”的信息。

        [Test]
        public void Select()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                var student = session.CreateQuery(" from Student").List<Student>().First();

                Console.WriteLine("学生名为：{0}", student.Name);

                Console.WriteLine("班级名为：{0}", student.Class.Name);
            }
        }

运行效果如图2.2.1所示，我们并没有再去调用查询方法，就能获取到关联的信息。

图2.2.1

三、多对一关联映配置介绍

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/02/24/nhibernate07.html

欢迎转载，但需保留版权。

本文链接

NHibernate从入门到精通系列(6)——基本映射

2011-02-23T16:21:00Z

内容摘要

　　映射定义概括

基本映射常用标签

NHibernate的类型

一、映射定义概括

1.1 映射定义（Mapping declaration）

对象和关系数据库之间的映射是用一个XML文档(XML document)来定义的。这个映射文档被设计为易读的，并且可以手工修改。映射语言是以对象为中心的，意味着映射是按照持久化类的定义来创建的，而非表的定义。

让我们打开上节课的映射例子：

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

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Product" table="T_Product" lazy="true" >
    <id name="ID" column="ID" type="Guid" >
      <generator class="assigned" />
    </id>

    <property name="Code" type="string">
      <column name="Code" length="50"/>
    </property>

    <property name="Name" type="string">
      <column name="Name" length="50"/>
    </property>

    <property name="QuantityPerUnit" type="string">
      <column name="QuantityPerUnit" length="50"/>
    </property>

    <property name="Unit" type="string">
      <column name="Unit" length="50"/>
    </property>

    <property name="SellPrice" type="decimal">
      <column name="SellPrice" precision="14" scale="2"/>
    </property>

    <property name="BuyPrice" type="decimal">
      <column name="BuyPrice" precision="14" scale="2"/>
    </property>

    <property name="Remark" type="string">
      <column name="Remark" length="200"/>
    </property>

  </class>
</hibernate-mapping>

其中xmlns为xml命名空间，我们能够在NHibernate的分发包src\nhibernate-mapping.xsd里找到XSD文件。我们可以将.xsd文件拷贝到Visual Studio安装目录的\Xml\Schemas中，以便带来NHibernate持久化类配置的提示功能。

二、基本映射常用标签

作为NHibernate这个ORM框架来说，一个实体类对应的是数据库中的一张表；类中的一个属性对应表中的一个字段；一个对象对应的是表中的一条记录。

2.1 hibernate-mapping

<hibernate-mapping>标签是NHibernate映射文件的根节点。

<hibernate-mapping
　 schema="schemaName" 数据库schema名称。

default-cascade="none|save-update" 默认的级联风格，(可选 - 默认为 none):。

auto-import="true|false" 　指定我们在使用查询语句的时候是否可以使用非全限定名。

assembly="AssemblyName" 　　

namespace="Namespace"　指定映射文件中的类的应用程序集名称和其所在的名称空间名，用来生成类的非全限定名。　

2.2 class

<class>标签是定义一个持久化类的。

2.3 id

<id>标签定义了该属性到数据库表主键字段的映射。

<id

name="PropertyName"                                  标识属性的名字。
        type="typename"                                          NHibernate类型的名字
        column="column_name"                                主键字段的名字。
        unsaved-value="any|none|null|id_value"         一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。
        access="field|property|nosetter|ClassName"   NHibernate用来访问属性值的策略。
        <generator class="generatorClass"/>
</id>

generator：主键生成策略。NHibernate提供了以下几种生成策略：

名称	说明	是否常用
`increment`	用于为int类型生成唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用	N
`identity`	对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。数据库返回的主键值返回的标识符是int类型的。	N
`sequence`	在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)，而在Interbase中使用生成器(generator)。返回的标识符是int类型的。	Y
`seqhilo`	使用一个高/低位算法来高效的生成int类型的标识符，给定一个数据库序列（sequence)的名字。	N
`uuid.hex`	用一个`System.Guid`的ToString()方法法生成字符串类型的标识符，字符串的长度由`format`参数定义。	N
`uuid.string`	用一个新的`System.Guid`实例的`byte[]`转化为字符串作为标示符。	N
`guid`	使用新的`System.Guid`实例作为标示符。
`guid.comb`	使用Jimmy Nilsson的算法生成一个新的`System.Guid`标示符。
`native`	根据底层数据库的能力选择identity, sequence 或者hilo中的一个。	Y
`assigned`	让应用程序在 `Save()`之前为对象分配一个标示符。	Y
`foreign`	使用另外一个相关联的对象的标识符。通常和`<one-to-one>`联合起来使用。	Y

2.4 composite-id

<composite-id>为联合主键。

<composite-id
        name="PropertyName"
        class="ClassName"                                               联合主键类的类名。
        unsaved-value="any|none"
        access="field|property|nosetter|ClassName">

        <key-property name="PropertyName" type="typename" column="column_name"/>             联合主键的属性
        <key-many-to-one name="PropertyName class="ClassName" column="column_name"/>      联合主键多对一属性
        ......
</composite-id>

注意的是，若使用联合主键，你的持久化类必须重载 Equals()和GetHashCode()方法。例子如下：

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

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Domain" namespace="Domain">
  <class name="Product" table="T_Product" lazy="true" >

    <composite-id name="ID" class="ProductID">
      <key-property name="Name" type="string">
        <column name="Name" length="50"/>
      </key-property>

      <key-property name="QuantityPerUnit" type="string">
        <column name="QuantityPerUnit" length="50"/>
      </key-property>

    </composite-id>

    <property name="Unit" type="string">
      <column name="Unit" length="50"/>
    </property>

    <property name="SellPrice" type="decimal">
      <column name="SellPrice" precision="14" scale="2"/>
    </property>

    <property name="BuyPrice" type="decimal">
      <column name="BuyPrice" precision="14" scale="2"/>
    </property>

    <property name="Remark" type="string">
      <column name="Remark" length="200"/>
    </property>

  </class>
</hibernate-mapping>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Domain
{
    public class Product
    {
        public virtual ProductID ID { get; set; }

        public virtual string Unit { get; set; }

        public virtual decimal SellPrice { get; set; }

        public virtual decimal BuyPrice { get; set; }

        public virtual string Remark { get; set; }
    }

    public class ProductID
    {
        public virtual string Name { get; set; }

        public virtual string QuantityPerUnit { get; set; }

        public override bool Equals(object obj)
        {
            var entity = obj as ProductID;
            if (entity == null)
            {
                return false;
            }

            return entity.Name == this.Name
                && entity.QuantityPerUnit == this.QuantityPerUnit;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}

运行效果如图2.4.1所示，包含联合主键的表已经生成成功。

图2.4.1

2.5 property

<property>标签是类定义了一个持久化类的属性。

三、NHibernate的类型

3.1 值类型映射表

NHibernate类型	.NET类型	Database类型	备注
AnsiChar	System.Char	DbType.AnsiStringFixedLength - 1 char
Boolean	System.Boolean	DbType.Boolean	在没有指定类型(type) 属性时的默认值。
Byte	System.Byte	DbType.Byte	在没有指定类型(type) 属性时的默认值。
Char	System.Char	DbType.StringFixedLength - 1 char	在没有指定类型(type) 属性时的默认值。
DateTime	System.DateTime	DbType.DateTime - ignores the milliseconds	在没有指定类型(type) 属性时的默认值。
Decimal	System.Decimal	DbType.Decimal	在没有指定类型(type) 属性时的默认值。
Double	System.Double	DbType.Double	在没有指定类型(type) 属性时的默认值。
Guid	System.Guid	DbType.Guid	在没有指定类型(type) 属性时的默认值。
Int16	System.Int16	DbType.Int16	在没有指定类型(type) 属性时的默认值。
Int32	System.Int32	DbType.Int32	在没有指定类型(type) 属性时的默认值。
Int64	System.Int64	DbType.Int64	在没有指定类型(type) 属性时的默认值。
PersistentEnum	System.Enum	潜在类型对应的DbType	不用在映射文件指定type="PersistentEnum".而是提供枚举的程序集全名, 让NHibernate用反射来猜测类型。枚举使用的潜在类型决定适当的DbType.。
Single	System.Single	DbType.Single	在没有指定类型(type) 属性时的默认值。
Ticks	System.DateTime	DbType.Int64	type="Ticks"必须被指定。
TimeSpan	System.TimeSpan	DbType.Int64	在没有指定类型(type) 属性时的默认值。
Timestamp	System.DateTime	DbType.DateTime - 取决于数据库支持	type="Timestamp"必须被指定。
TrueFalse	System.Boolean	DbType.AnsiStringFixedLength - 一个字符,'Y' 或者'N'	type="TrueFalse"必须被指定。
YesNo	System.Boolean	DbType.AnsiStringFixedLength - 一个字符,'Y' 或者'N'	type="YesNo"必须被指定。

3.2 应用类型映射表

NHibernate Type	.NET Type	Database Type	Remarks
AnsiString	System.String	DbType.AnsiString	type="AnsiString"必须被指定。
CultureInfo	System.Globalization.CultureInfo	DbType.String - 表明文化(culture)的5个字符	在没有指定类型(type) 属性时的默认值。
Binary	System.Byte[]	DbType.Binary	在没有指定类型(type) 属性时的默认值。
Type	System.Type	DbType.String 保存应用程序集权限定名。	在没有指定类型(type) 属性时的默认值。
String	System.String	DbType.String	在没有指定类型(type) 属性时的默认值。

3.3 二进制类型映射表

NHibernate Type	.NET Type	Database Type	Remarks
StringClob	System.String	DbType.String	type="StringClob"必须被指定。整个字段在内存里可读。
BinaryBlob	System.Byte[]	DbType.Binary	type="BinaryBlob"必须被指定。整个字段在内存里可读。
Serializable	Any System.Object 必须标注可序列化标签	DbType.Binary	type="Serializable" 应该被指定. 如果不能为属性找到NHibernate类型，这是最后可依靠的类型。

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/02/24/nhibernate06.html

欢迎转载，但需保留版权。

本文链接

NHibernate从入门到精通系列(5)——持久对象的生命周期(下)

2011-02-17T18:30:00Z

内容摘要

持久化类

持久化生命周期中的回调

合法性验证回调

一、持久化类(Persistent Classes)

　　1.1 什么是持久化类

回答这个问题之前先回答什么是持久化。所谓的持久化就是把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。然而持久化类就是持久化数据的载体，在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的Customer和Order）类就是持久化类。不能认为所有的持久化类的实例都是持久的状态——一个实例的状态也可能是瞬时的或脱管的。如果这些持久化类遵循一些简单的规则，NHibernate能够工作得更好，这些规则也被称作简单传统CLR对象(POCO:Plain Old CLR Object)编程模型。

之前用到的“Product”类，就是持久化类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Domain
{
    /// <summary>
    /// 商品
    /// </summary>
    public class Product
    {
        /// <summary>
        /// ID
        /// </summary>
        public virtual Guid ID { get; set; }

        /// <summary>
        /// 编号
        /// </summary>
        public virtual string Code { get; set; }

        /// <summary>
        /// 名称
        /// </summary>
        public virtual string Name { get; set; }

        /// <summary>
        /// 规格
        /// </summary>
        public virtual string QuantityPerUnit { get; set; }

        /// <summary>
        /// 单位
        /// </summary>
        public virtual string Unit { get; set; }

        /// <summary>
        /// 售价
        /// </summary>
        public virtual decimal SellPrice { get; set; }

        /// <summary>
        /// 进价
        /// </summary>
        public virtual decimal BuyPrice { get; set; }

        /// <summary>
        /// 备注
        /// </summary>
        public virtual string Remark { get; set; }
    }
}

然而持久化类须满足一定的规则。

1.2持久化类的规则

实现一个默认的（即无参数的）构造方法（constructor）
提供一个标识属性（identifier property）（可选）
使用非密封（non-sealed）类以及虚方法（virtual methods） (可选)

二、持久化生命周期中的回调

2.1 ILifecycle接口介绍

持久化类可以实现ILifecycle接口，它可以提供一些用于回调的方法，可以让持久化对象在Save或Load之后，或者在Delete或Update之前进行必要的初始化与清除步骤。

让我们看一下ILifecycle接口　

    public interface ILifecycle
    {
        LifecycleVeto OnDelete(ISession s);
        void OnLoad(ISession s, object id);
        LifecycleVeto OnSave(ISession s);
        LifecycleVeto OnUpdate(ISession s);
    }

其中ILifecycle接口的方法如下：

(1)	`OnSave` - 在对象即将被save或者insert的时候回调
(2)	`OnUpdate` - 在对象即将被update的时候回调（也就是对象被传递给`ISession.Update()`的时候)
(3)	`OnDelete` - 在对象即将被delete(删除)的时候回调
(4)	`OnLoad` - 在对象刚刚被load(装载)后的时候回调

如果OnSave(), OnUpdate() 或者 OnDelete()返回LifecycleVeto.Veto，那么操作就被悄悄地取消了。如果其中抛出了CallbackException异常，操作被取消，这个异常会被继续传递给应用程序。

2.2 ILifecycle的demo

实体：

/// <summary>
    /// 商品
    /// </summary>
    public class Product : ILifecycle
    {
        /// <summary>
        /// ID
        /// </summary>
        public virtual Guid ID { get; set; }

        /// <summary>
        /// 编号
        /// </summary>
        public virtual string Code { get; set; }

        /// <summary>
        /// 名称
        /// </summary>
        public virtual string Name { get; set; }

        /// <summary>
        /// 规格
        /// </summary>
        public virtual string QuantityPerUnit { get; set; }

        /// <summary>
        /// 单位
        /// </summary>
        public virtual string Unit { get; set; }

        /// <summary>
        /// 售价
        /// </summary>
        public virtual decimal SellPrice { get; set; }

        /// <summary>
        /// 进价
        /// </summary>
        public virtual decimal BuyPrice { get; set; }

        /// <summary>
        /// 备注
        /// </summary>
        public virtual string Remark { get; set; }

        public virtual LifecycleVeto OnDelete(NHibernate.ISession s)
        {
            Console.WriteLine("您调用了Delete()方法！");
            return LifecycleVeto.NoVeto;
        }

        public virtual void OnLoad(NHibernate.ISession s, object id)
        {
            Console.WriteLine("您调用了Load()方法！");
        }

        public virtual LifecycleVeto OnSave(NHibernate.ISession s)
        {
            Console.WriteLine("您调用了Save()方法！");
            return LifecycleVeto.NoVeto;
        }

        public virtual LifecycleVeto OnUpdate(NHibernate.ISession s)
        {
            Console.WriteLine("您调用了Update()方法！");
            return LifecycleVeto.NoVeto;
        }
    }

单元测试：

[TestFixture]
    public class LifecycleTest
    {
        private ISessionFactory sessionFactory;

        private static readonly Guid s_id = Guid.NewGuid();

        [SetUp]
        public void Init()
        {
            var cfg = new NHibernate.Cfg.Configuration().Configure("Config/hibernate.cfg.xml");
            sessionFactory = cfg.BuildSessionFactory();
        }

        [Test]
        public void SaveTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        var product = new Product
                        {
                            ID = s_id,
                            BuyPrice = 10M,
                            Code = "ABC123",
                            Name = "电脑",
                            QuantityPerUnit = "20x1",
                            SellPrice = 11M,
                            Unit = "台"
                        };

                        session.Save(product);

                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }

        [Test]
        public void UpdateTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        var product = session.Load<Product>(s_id);

                        product.BuyPrice = 12M;
                        session.Update(product);

                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }

        [Test]
        public void DeleteTest()
        {
            using (ISession session = this.sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        var product = session.Load<Product>(s_id);

                        session.Delete(product);

                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
    }

运行SaveTest()方法的效果，如图2.2.1所示。

图2.2.1

运行UpdateTest()方法的效果，如图2.2.2所示。奇怪的是OnUpdate()回调没有工作，这是因为在NHibernate 1.x 以后的版本，ILifecycle接口已经不建议使用了。

图2.2.2

运行DeleteTest()方法的效果，如图2.2.3所示。

图2.2.3

三、合法性验证回调

合法性验证（IValidatable）回调是在持久化类在保存其持久化状态前进行合法性检查的接口。

public interface IValidatable
{
void Validate();
}

如果发现对象违反了某条规则，应该抛出一个ValidationFailure异常。在Validatable实例的Validate()方法内部不应该改变它的状态。

和ILifecycle接口的回调方法不同，Validate()可能在任何时间被调用。应用程序不应该把Validate()调用和商业功能联系起来。

实现代码如下：

public class Product : IValidatable
    {

        ....

        /// <summary>
        /// 进价
        /// </summary>
        public virtual decimal BuyPrice { get; set; }

        public virtual void Validate()
        {
            if (this.BuyPrice >= 12M)
            {
                throw new ValidationFailure("进货价格太高，无法受理！");
            }
        }
    }

运行效果如图3.1所示

图3.1

总结：目前NHibernate 3.0版本中不建议使用ILifecycle和IValidatable接口。因为这样NHibernate框架就会对持久化类产生侵入性。

代码下载

出处：http://www.cnblogs.com/GoodHelper/archive/2011/02/18/nhibernate05.html

欢迎转载，但需保留版权。

本文链接