Without SSH/JSP/Servlet,不走寻常路,Java可以更酷

标题的构思来源于Rod Johnson的那本"Without EJB"以及CCTV5中一句耳熟能详的广告词，
不过此文并不是用来批判SSH(Struts、Spring、Hibernate)/JSP/Servlet的，
也不是为某品牌做广告，而是用来分享这将近一年来的研究心得。

去年圣诞节时曾在JavaEye发过一两篇文章，不过现在找不到了，
文章内容提到要在3个月左右的时间内设计出一个有别于SSH的新型MVC框架，
设计的起点最初是以JSP/Servlet为基础的，虽然在两个多月后有了个雏形，
但是跟Rails这样的框架相比还是没有明显的优势，
比如在不使用反射的情况下，
很难将不同的uri对应到Servlet类中的public方法。
(Servlet类指的是继承自javax.servlet.http.HttpServlet的类)
每次修改Servlet类的源代码时总得经过烦人的手工编译步骤(有时还不得不重启Tomcat)，
还有与数据库打交道的模型层也得人工干预，一堆烦人的映射配置。

那三个月内时常有沮丧感，似乎已走近了死胡同!
后来心一狠，决心甩开JSP/Servlet那一堆条条框框，把设计的起点再往下深一个层次。
因为2007年曾详细研究过Java语言的编译器(javac)实现细节，所以从编译器着手，
但是编译器的强项在于分析Java源代码，无法处理Http请求，
接着在网上把Tomcat6的源代码下下来研究了三个月，
期间顺便研究了Sun公司的超轻量级Http服务器"com.sun.net.httpserver"的源代码，
同时详细学习HTTP/1.0(RFC1945)与HTTP/1.1(RFC2616)协议。

但是Tomcat6过于臃肿了，包含的Java文件超过了1300个，
光是解析server.xml与web.xml的代码看完后就让人有烦躁感。
(如org\apache\tomcat\util\digester与org\apache\catalina\startup包中的很多类)

另外最重要一点，Tomcat6采用的是Eclipse JDT编译器，仅仅是用来编译JSP文件，
编译器在控制层没有发挥一点作用。
而Sun公司的超轻量级Http服务器又过于简单了，连HTTP/1.1的大多数功能都没实现，
除了参考一下它的SSL实现外基本上毫无价值。

本想在现有的JSP/Servlet容器上做一下简单扩展就得了，
哪知也是四处碰壁(还下过Jetty的源代码下来看了一会，结果发现比Tomcat6还糟)，
后来决定对Tomcat6与Sun的Http服务器进行大刀阔斧的改造，
完成了一个精简版的改良后的基于NIO的Http服务器(目前的版本只有60个左右的Java源文件)，
并且能跟Javac编译器完美结合，能直接运行Java源文件。

在模型层这一块，最初是从书上和网络上对Hibernate进行应用层次的研究，
但是并不想深入源代码，因为代码量也实在是太多了，倒是对Ibatis2.0深入研究了一下，
Ibatis2.0代码量比较少，也简单，看了不到一星期就基本上看完了，不过现在并没留下深刻映象，
因为并没发现什么特别出彩的地方，Ibatis2.0还是离不开xml，而我想要完全抛弃xml。

当然，不管Hibernate也好，Ibatis2.0也好，相比Rails的ActiveRecord还是逊色了点，
不过我的目标并不是要造一个Hibernate、Ibatis2.0或ActiveRecord这样的轮子，
我的要求更高，我在想如何才能写更少的代码，如何才能实现自动化？
可不可以在服务器启动时或运行时动态解析数据库的元数据，
让编译器跟据这些元数据动态生成类呢？
接着我转去研究JDBC-1.2/JDBC-2.1/JDBC-3.0/JDBC-4.0规范，研究数据库驱动的开发手册。
我得从零开始，我目前的实现是这样做的：你可以在你自己的Java源文件中直接引用动态生成的类，
就像这些类是你自己写的一样，ORM已基本上实现自动化了，2.9 节专门讲Douyu的ORM。

最后一点值得一提的是，我在Java语言层次引入了权限管理模型，
不过你别担心，我并没有引入新的Java语言语法，
只是借助Annotation扩充了某些特殊的语义。
目前这个权限管理模型的粒度只是划分为功能、字段权限两个等级，
并没有实现与具体业务相关的数据权限，不过在未来的路线图中有打算引入工作流模型，
到时会努力尝试各种实现数据权限的方案。

与权限相关的细节请看2.8节 Douyu的权限模型。



折腾了半年后，发现已不再是个MVC框架了，我想称为平台更合适，
一种运行在JVM之上的新型平台，我给她起了个名字: Douyu
(呵呵，名字的由来暂时保密，也许你能猜出来。。。)



虽然孤军奋战将近一年，自我感觉小有成就，但是还有很多不怎么满意的地方，
各位大牛们也许更牛，看见不爽砸砖头便是。



Ok，上干货。




1. 安装配置


(这里只针对Windows平台，特别是XP操作系统，因为我没其他试验环境)



1.1 安装JDK


Douyu是在JDK1.6下开发的，不支持也不打算支持JDK1.4及更早的版本，JDK1.5我没有测试过，
所以我只能推荐你安装JDK1.6了，安装细节我想你都会，
唯一要注意的一点是:最好是建个JAVA_HOME环境变量，然后把%JAVA_HOME%\bin加入到Path中，
因为在Douyu服务器的启动脚本中并没有进行过多的环境检测，
而是直接使用了%JAVA_HOME%\bin目录下的java命令来启动Java HotSpot VM。


1.2 安装Douyu服务器

Douyu项目主页目前放在:
http://code.google.com/p/douyu/

请先下载二进制版的压缩文件:
http://douyu.googlecode.com/files/Douyu_0_1_0.rar

目前的版本是:0.1.0，版本号很小，但大多数功能都包含了，
我并不推荐你用于工业级别的产品开发，
因为还不稳定，目前只适合分享、交流、尝鲜目的。

下下来后直接解压到一个你选定的目录(假定你解压到了D:\Douyu目录)

D:\Douyu目录里头有下面7个目录(跟Tomcat6差不多):

apps  //应用程序的源代码放在这里，里头有一些java源文件是下面的演示中用到的，当然你可以全都删了。
bin   //服务器的启动脚本和运行时类库都在这里
conf  //服务器的配置文件放在这里
lib   //应用程序使用到的第三方类库(比如数据库驱动)都放在这里，初始情况下是个空目录
logs  //存放服务器运行期间的日志(目前日志只是输出到控制台)，初始情况下是个空目录
temp  //服务器运行期间用到的临时文件夹(比如上传文件时可能会用到)，初始情况下是个空目录
work  //服务器运行期间的工作目录，初始情况下是个空目录

了解了这些就足够了，目前你不需要做任何配置。







2. 体验Douyu



2.1 如何运行Douyu服务器？


点"开始->运行"，输入cmd，打开一个控制台，切换到D:\Douyu\bin目录，
然后输入 douyu  启动Douyu服务器 (要关闭Douyu服务器连按两次Ctrl+C既可)
见下图:



如果你是第一次打开操作系统第一次启动JVM运行Java程序
或是隔了一个小时左右重新启动JVM运行Java程序，这时可能要等待几秒钟(5--10秒)，
出现这种情况并不是Douyu服务器的问题，而是JVM本身或操作系统的问题，
通常启动Douyu服务器如果不加载数据库的话，一般在一秒钟内就能启动完成了。

Douyu服务器默认情况下监听的主机名是: localhost，端口: 8000

如果你不喜欢这样的默认配置，
或者最常见的情况是端口8000被占用了
(一般抛出异常: java.net.BindException: Address already in use)
你可以打开conf\server.java这个服务器配置文件，
配置文件本身就是一个java源文件，参数的配置使用Java语言的Annotation语法，
所有与服务器配置有关的都是Annotation或是Enum，全都在com.douyu.config包中定义。

import com.douyu.config.*;

@Server(
	port=8000,
	.................

要修改默认主机名和端口，请修改hostName和port的值，
hostName是一个字符串，可以用IP地址来表示，port是一个整型(int)值。


其他很多参数先不罗列了，使用到时再详细说明。


当你修改了conf\server.java后，你也不需要自己去手工编译它，
启动Douyu服务器时，Douyu会自行决定是否要编译它。
如果conf\server.java存在语法错误，那么编译失败，
Douyu服务器的启动也会失败，同时向你显示编译错误信息。



下文中假定Douyu服务器已启动，监听的主机名是: localhost，端口是: 8000
以下所有例子都经过严格测试了，

我的JRE版本:
D:\Douyu\bin>java -version
java version "1.6.0_16"
Java(TM) SE Runtime Environment (build 1.6.0_16-b01)
Java HotSpot(TM) Client VM (build 14.2-b01, mixed mode, sharing)

测试浏览器用了两个:

傲游浏览器(IE6.0),
谷歌浏览器(Chrome 3.0.195.27)





2.2 Hello World!



2.2.1 程序代码

//对应apps\HelloWorld.java文件

import java.io.PrintWriter;
import com.douyu.main.Controller;

@Controller
public class HelloWorld {
	public void index(PrintWriter out) {
		out.println("Hello World!");
	}
}

2.2.2 手工编译已经Out了，你再也不需要这一步了。


2.2.3 运行HelloWorld

打开你心爱的浏览器，输入 http://localhost:8000/HelloWorld
如果你能看到下图中所示内容，恭喜你，你己经进入了Douyu的精彩世界。



(注:这是你第一次直接运行Java源文件，可能会等几秒钟(2--4秒)，因为Douyu得初始化编译器)


2.2.4 程序代码说明

com.douyu.main包中的类大多数是Annotation，还包含一些重要的接口和类，
相当于java.lang，是你用Douyu开发程序时最常用到的，也是通往其他模块的快速入口，
本想让com.douyu.main包中的类像java.lang一样让编译器自动导入的，
但是考虑到很多开发人员更偏爱使用IDE，不同IDE内置的编译器不一样，
从而会引起找不到com.douyu.main包中的类的问题，所以最后决定放弃这样的设计了。

@Controller 这个Annotation是用来告诉Douyu这是一个控制器，
当你在浏览器的地址栏中输入http://localhost:8000/HelloWorld 这样的uri时，
浏览器内部通常会生成一个HTTP GET请求消息，消息内容类似这样:

GET /HelloWorld HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg,......
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; Maxthon)
Host: localhost:8000
Connection: Keep-Alive

不过这里并不打算介绍HTTP协议，如果你有兴趣，可以把RFC2616下下来研究。

Douyu服务器收到浏览器发来的请求消息后，
特别留意 "GET /HelloWorld HTTP/1.1" 这一行消息，
其中的"/HelloWorld"表示想要获取Douyu服务器上的哪些资源，
资源有静态的(如html、jpg等文件)，也有动态的，在Douyu服务器中动态资源只有一种，
凡是带有@Controller这个Annotation的Java源文件都是可以直接通过uri访问的动态资源。

不过Douyu服务器不能根据uri的表面特征一眼就看出它是动态的还是静态资源，
服务器内部有一个专用的资源装载器，装载器的搜索根目录是从apps这个地方开始的，
资源装载器会尝试将apps目录与uri组合成一个java.io.File对象，
如果File对象存在，那么它就是一个静态资源，
然后由Douyu服务器内部的静态资源处理器给浏览器发送包含有文件内容的响应消息；

如果File对象不存在，资源装载器把请求的uri当成一个类名，
然后尝试采用类装载器的方式装载类，如果找不到那么就直接返回未找到(404)消息；
如果找到了，并且uri是第一次请求的，资源装载器会返回java源文件，
然后把java源文件交给Douyu服务器内置的编译器处理，编译器的处理过程很复杂，
这里就不深入说明了，总之它会为你动态生成HelloWorld的实例，
然后调用它的index这个缺省的public方法，
之后调用out.println()方法把"Hello World!"发送给浏览器。

2.3 控制器层与视图层的协作


2.3.1 程序代码

//控制器层的代码
//对应apps\WhatTime.java文件

import java.util.Date;
import java.util.HashMap;

import com.douyu.main.Context;
import com.douyu.main.Controller;

@Controller
public class WhatTime {
	public void index(String name, Context context) {
		HashMap<String,Object> paramMap = new HashMap<String,Object>();
		paramMap.put("name",name);

		context.out("WhatTime.html", paramMap, new ParamWrapper());
	}

	public static class ParamWrapper {
		Date time = new Date();
	}
}

//视图层的代码
//对应apps\WhatTime.html文件

<HTML>
<HEAD><TITLE>现在几点了?</TITLE></HEAD>
<BODY>
你好: ${name}, 现在的时间是: ${time}
</BODY>
</HTML>

2.3.2 运行 WhatTime

打开浏览器，输入 http://localhost:8000/WhatTime?name=Douyu
结果类似这样:




2.3.3 程序代码说明

WhatTime类的功能很简单: 就是提供报时服务。
index方法与第一个例子有所不同，第一参数用来接收请求uri中的name参数值，
第二个参数的类型是Context，它是一个接口，在com.douyu.main包中定义。
Context是最核心的接口，定义了很多重要的方法，
不过这里只介绍out(String template, Object... paramWrappers)方法。
out方法是控制器层与视图层通信的唯一通道。

先来看这一行代码:
context.out("WhatTime.html", paramMap, new ParamWrapper());
上面的WhatTime.html文件就相当于一个模板文件，对应out方法的第一个参数，
WhatTime.html模板文件中的${name}与${time}表示一些占位标记，
意思是告诉控制器:在把我的内容发送到浏览器前，先把这些占位标记提换成实际的参数值。

实际的参数值从哪里取呢？我想你早就看出来了: 从paramWrappers这个可变数组中取。
比如上面那行代码中的paramMap和new ParamWrapper()都可以称为参数包装器，
参数包装器可以是一个Map，也可以是一个普通的类。

如果你在调用out方法时不提供任何参数包装器，那么不会对任何占位标记进行替换，
这种情形通常适用于直接发送静态资源文件。

如果你在调用out方法时提供了多个参数包装器，
那么参数值的查找顺序是按调用out方法时参数包装器出现的先后顺序进行的，
比如上例中，在替换${name}这个占位标记时，先从paramMap中查找(类似这样:paramMap.get("name"))，
因为name的值已经在
paramMap.put("name",name);
这一行代码中加入了，所以查找成功，不再往下进行。

当替换${time}这个占位标记时，也是先从paramMap中查找(类似这样:paramMap.get("time"))，
但是返回null，接着从new ParamWrapper()这个参数包装器中查找，
控制器识别出ParamWrapper类不是一个Map，所以采用反射技术，事先查找是否定义了time()方法，
因为ParamWrapper类没有定义time()方法，所以再查找是否定义了名叫time的实例变量，
最后找到了，time这个实例变量是Date类型，把它转换成字符串后替换${time}这个占位标记，
最后就可以把模板文件的内容发送给浏览器了。

2.4 神奇的Action



2.4.1 程序代码

//对应apps\SupernaturalAction.java文件

import com.douyu.main.Context;
import com.douyu.main.Controller;

@Controller
public class SupernaturalAction {
	public void index(Context context) {
		context.out("User.html");
	}

	public void showUser(User user, java.io.PrintWriter out) {
		out.println("姓名:"+user.name);
		out.println("年龄:"+user.age);
	}
}

//对应apps\User.java文件

import com.douyu.main.Form;
import com.douyu.main.Setter;

@Form
public class User {
	String name;
	int age;

	@Setter
	public void init(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

//对应apps\User.html文件

<HTML>
<HEAD><TITLE>User</TITLE></HEAD>
<BODY>
<FORM METHOD=POST ACTION="SupernaturalAction/showUser">
	姓名:<INPUT TYPE="text" NAME="name"><br>
	年龄:<INPUT TYPE="text" NAME="age"><br>
	<INPUT TYPE="submit">
</FORM>
</BODY>
</HTML>

2.4.2 运行 SupernaturalAction


打开浏览器，输入 http://localhost:8000/SupernaturalAction
结果类似这样:




填写完表单,点击提交按钮后的结果:




2.4.3 程序代码说明


上面的代码所完成的功能很简单: 先显示一个User表单让你填写，然后输出你填写的内容。
不过这不是我的主要用意，我的意图是想通过这个非常简单的例子向你说明什么是"Action"?

Action其实就是一个方法，如果一个类带有@Controller 那么在这个类中定义的所有public方法
都是一个Action，你可以通过"类名/方法名"这样的uri来访问这个Action，
例如上面apps\User.html文件中的ACTION="SupernaturalAction/showUser"就表示由SupernaturalAction中
的showUser方法来处理表单。

如果你在uri中未指明方法名，比如http://localhost:8000/SupernaturalAction，
那么就会调用默认的index方法，
http://localhost:8000/SupernaturalAction
与 http://localhost:8000/SupernaturalAction/index 是等价的。

如果你不喜欢index这个默认的方法名，而是喜欢main这样的方法名
你可以把 @Controller 改成 @Controller(defaultAction="main")


另外一个很神奇的地方在于方法声明中的参数，
如果你是一个很细心的人你可能早已发现了一件有趣的事，
前面三小节给出的示例中每个Controller类中都有index方法，但是方法的参数是不同的，
再列出来对比一下:

第1个例子是: index(PrintWriter out)
第2个例子是: index(String name, Context context)
第3个例子是: index(Context context)

如果你学习过Sun发明的Servlet技术，你应该对下面这两个方法很熟悉:
doPost(HttpServletRequest req, HttpServletResponse resp)
doGet(HttpServletRequest req, HttpServletResponse resp)


前者的方法参数类型、个数、顺序都是活的，是由正在写程序的人自己定的，
而后者都是死的，是由Sun在规范中事先定好的，你只能去覆盖doPost、doGet。

通俗一点来讲就是:
主动权在我，要由我说的算，我要什么你就得给我什么；
而不是我去顺从你，你有什么我只能用什么。


能达到这样的灵活性要归功于强大的编译器，
编译器在编译源代码时会根据Douyu服务器运行期间的上下文信息推断出你想要做什么?
比如你想要一个PrintWriter，那么就给你一个能向浏览器输出信息的PrintWriter，
你想要一个Context，那么就把代表上下文的Context实例传给你，
你想要获取某一个Http请求参数值(如上面的String name)也同样满足你。


接着再来看看showUser的参数声明:
showUser(User user, java.io.PrintWriter out)

唯一陌生的地方是:User user，
请先回过头去看看apps\User.java文件的内容，
如果你熟悉JavaBeans，那么一定写过一堆的setter/getter方法吧，
User类有点类似JavaBeans，但又不大一样。

如果你给一个类加上 @Form 这个Annotation，然后你把这个类作为Action方法参数的类型，
那么编译器就会推断出你想要把Http请求参数值自动装配到这个类的实例变量中,
接着编译器就会在这样的类中继续寻找所有带有 @Setter 的public方法，
然后解析方法参数，这一步跟解析Action方法参数一样，
但是在这一步会忽略掉所有的带有@Form 类型的其他参数。
(比如，要是像这样:init(String name, int age, User user)，那么直接给user变量赋 null 值)


下面的代码片断:

	@Setter
	public void init(String name, int age) {
		this.name = name;
		this.age = age;
	}

就是最关键的地方，
它告诉编译器：把名叫"name"和"age"的参数值准备好，然后调用init。

参数的名称很重要，必须跟html表单中一样，否则会找不到实际的值，只能给你null或者0这样的默认值。

不过，你也不必担心，通常每个表单在实际应用中都对应数据库中的一张表，
Douyu已经考虑到这个问题了，已将模型层和控制层完美结合，
几乎可以实现自动化了(不过不是采用@Setter方式)，
所以通常你不必另外写一个对应html表单的类。

2.5 文件上传



2.5.1 程序代码

//对应apps\FileUpload.java文件

import java.io.File;
import java.io.PrintWriter;

import com.douyu.main.Context;
import com.douyu.main.Controller;

import com.douyu.http.UploadedFile;

@Controller
public class FileUpload {
	public void index(Context c) {
		c.out("FileUpload.html");
	}

	public void upload(UploadedFile[] uploadedFiles, UploadedFile file1,
		String description, PrintWriter out) {
		
		out.println("说明: "+description);
		out.println();

		if(uploadedFiles != null) {
			for(UploadedFile uf : uploadedFiles) {
				//注意这里，file1与uploadedFiles中的某一个元素指向同一个对象
				if(file1 == uf) {
					out.println("这是文件1:");
					out.println();
				}

				out.println("大小  : "+uf.getSize()+" 字节");
				out.println("类型  : "+uf.getContentType());
				out.println("文件名: "+uf.getSimpleName());
				out.println("全名  : "+uf.getFullName());
				out.println("路径名: "+uf.getPathName());

				out.println();
				out.println("文件内容:");
				out.println("--------------------------------------");
				out.println(uf.getContent());
				out.println("--------------------------------------");

				out.println();

				File file = new File("D:/Douyu/temp/uploadedFiles", uf.getSimpleName());

				try {
					uf.saveTo(file);
					out.println("已保存到: "+file);
				} catch(Exception e) {
					out.println("出错了: "+e);
				}
				out.println();
				out.println();
			}
		}
	}
}

//对应apps\FileUpload.html文件

<HTML>
<HEAD><TITLE>文件上传</TITLE></HEAD>
<BODY>
    <FORM ENCTYPE="multipart/form-data" METHOD="POST" ACTION="FileUpload/upload">
    文件1:<INPUT NAME="file1" TYPE="file" size="50"><br>
	文件2:<INPUT NAME="file2" TYPE="file" size="50"><br>

	说明 :<TEXTAREA NAME="description" ROWS="5" COLS="50"></TEXTAREA><br>

    <INPUT TYPE="submit" VALUE="上传">
    </FORM>
</BODY>
</HTML>

2.5.2 运行 FileUpload

打开浏览器，输入 http://localhost:8000/FileUpload
结果类似这样:




点击"浏览"按钮选择上传的文件,然后再点击"上传"按钮后的结果:




2.5.3 程序代码说明

上面的代码做了什么事应该是一目了然的，唯一陌生的地方就是出现了UploadedFile这么个东西。

UploadedFile实际上是一个接口，在com.douyu.http包中定义，如包名所暗示的那样，
com.douyu.http包中定义的接口或类都是跟http协议有关的，这一节只介绍UploadedFile接口.

UploadedFile接口用来表示一个已经上传到服务器的文件，
这个文件的内容通常是放在内存中或是在某个临时目录中。UploadedFile接口定义的方法并不多，
在上面的例子中已演示了大多数方法的用法，其中最有用的就是saveTo方法了，
调用saveTo方法可以把内存中或临时目录中的文件内容保存到你指定的目录中，
比如上例中就是把所有上传的文件都保存到D:/Douyu/temp/uploadedFiles目录，
并且新文件名跟上传的文件名一样。

当请求处理结束时，JVM会在合适的时间回收上传文件所占用的内存空间。
如果上传文件被放在临时目录中，那么在请求处理结束时也会被自动清除。


注意，出于安全考虑，最好不要将上传的文件保存到Douyu服务器的apps和work目录，
因为这样会导致安全问题，比如，如果别人上传了一个 Evil.java 文件，
Evil.java的代码是用来删除你硬盘上的文件的，接着你把它保存到了apps目录，
那么别人就可以通过 http://localhost:8000/Evil 这样的uri来执行Evil.java文件。

Douyu服务器目前的实现并没有过多的考虑安全问题，
安全问题会在接下来的版本中逐步完善。

2.6 再论Action


看完 2.5节的例子后你可能对Douyu的具体实现更加好奇了，
FileUpload这个控制器没有实现任何接口也没有继承任何类，
FileUpload这个类名也不一定就叫"FileUpload"，只要你喜欢你可以取其他名字。

FileUpload定义的各种与Action相关的方法名、方法参数都是由你自由定义的，
比如，你可以把upload这个方法名改成毫无意义的"aaaa"，
只要你把apps\FileUpload.html文件中的
ACTION="FileUpload/upload"改成ACTION="FileUpload/aaaa"同样能够正确运行。



接下来再深入一点，看看Douyu内置的编译器是怎样推断你想要它做什么?

重新观察一下2.5节中提到的FileUpload类，它定义了一个upload方法，方法参数如下所示:

public void upload(UploadedFile[] uploadedFiles, UploadedFile file1,
		String description, PrintWriter out)

方法参数的类型分别是:
com.douyu.http.UploadedFile[]
com.douyu.http.UploadedFile
java.lang.String
java.io.PrintWriter

编译器首先对方法参数的类型进行分类，
参数的类型总体上可以分为下面这些:

1) Douyu内置的类型:
如上面的: com.douyu.http.UploadedFile,
以及出现过多次的:com.douyu.main.Context,

还有后面的例子中将会出现的:
com.douyu.http.HttpRequest
com.douyu.http.HttpResponse

这些类型通常是接口类型，用户可以使用Douyu提供的这类接口来完成具体的任务。

2) 带有 @Form 声明的类:
如前面出现的User类就是这种情况

3) int、long、float、double、boolean、byte、char、short这8个基本类型:

4) 与8个基本类型对应的包装类:
java.lang.Integer
java.lang.Long
java.lang.Float
java.lang.Double
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.lang.Short

5) Java平台类库中提供的一些特殊类:
java.lang.String
java.io.PrintWriter

6) 数组类型
目前只支持一维数组，并且数组元素的类型只能是:
java.lang.String 和 com.douyu.http.UploadedFile

7) 动态生成的模型类
这些类是与数据库有关的，通常每一个模型类对应数据库中的一张表，
前面都没有出现过这种类型，这种情况在下面的章节中叙述。


因为每个Action对应的方法都是可以通过uri来调用的，
换句话说，每个Action实际上处理的是Http请求，同时返回一个响应消息.

当你在定义这个Action对应的方法的参数时，
实际上你已经告诉了编译器：你想处理什么样的数据(或参数值)，请把数据(或参数值)准备好传给我。

现在的关键问题是:参数值从哪里来，编译器怎样才能正确获取参数值呢？
解决问题的关键在于 参数类型和参数名。

如果参数类型是上面所列的 3)和 4) 以及java.lang.String 和 java.lang.String[](字符串数组),
因为在一个Http请求中可能包含很多参数(如用POST方式提交的表单或用GET方式提交的很多查询参数)，
所以编译器不可能仅从参数的类型推断出你想要它做什么，
比如，如果Http请求中包含4个参数:
p1 = 1;
p2 = 2;
p3 = "a";
p4 = "b";

你定义了一个Action:
action1(int a, int b, String c, String d)
到底给参数a传1还是传2呢？参数c传给它字符串"a"还是"b"？
这种情况显然会增加歧义，所以对于这些参数类型，你必须同时用参数名来区分不同的参数。
把上面的Action改成这样才能正确工作:
action1(int p1, int p2, String p3, String p4)

值得一提的是，Http请求中的参数值通常都是字符串类型的，
不过并不需要你进行手工转换了，编译器会跟据你指定的参数类型自动完成转换工作。

如果Action中指定的参数在Http请求参数中找不到或转换失败，
那么将使用默认值，如int、long默认值为0, float为0.0，boolean为false，
基本类型的包装类和String的默认值都为null,
java.lang.String[] 字符串数组类型通常是用来获取Http请求中某一参数的多个取值的，
如果找不到也返回null.



另一种情况不限制Action参数名称的取法，编译器仅根据参数类型就知道你想要做什么，
因为这样的参数类型没有歧义，是唯一的，
比如常见到的:
com.douyu.main.Context
java.io.PrintWriter
以及
com.douyu.http.HttpRequest
com.douyu.http.HttpResponse
还有 2) 和 7)中的自定义类型都是唯一的，你可以随意取名，
比如:可以是 index(Context context) 或者是更简短的 index(Context c)


2.5节的upload方法更有趣，UploadedFile接口实际上也算是Http请求中某种特殊的参数，
它代表了"multipart/form-data"表单中的某一个file元素，
如果你要获取具体的某一个file元素，除了把Action方法的参数类型声明为UploadedFile接口外，
你还必须严格指定参数名称，就像2.5节中出现的"UploadedFile file1"那样，
参数名file1就代表文件1；如果你上传的是多个文件，要是你不在乎每个文件的特殊情况，
那么你可以像2.5节中出现的"UploadedFile[] uploadedFiles"那样，
随意的声明一个UploadedFile数组，数组名称你可以任取，可以是uploadedFiles也可以是files。


总结一个规律就是：
当你要获取Http请求中的某个具体参数值时，
除了在Action方法中明确指明参数类型外，你还必须严格指定参数名称，
其他类型的参数只要编译器能识别，就会正确无误的传给你，
不能识别的类型要么返回默认值要么返回null。


至此，你应该知道静态强类型语言(Java)比动态无类型声明的脚本语言(Ruby、PHP)强大的地方了吧!
静态强类型语言的编译器能在编译源码期间就能收集到很多有用的类型信息，
在很大程度上跟据这些类型信息就能推断出你想做什么，事先就能做好决策，
这使得编译器在控制器层发挥出很大的威力，不必等到运行时才做决策，
另一方面可以大大提高程序运行性能，同时又具有足够的灵活性，
比如将来Douyu提供了更多有用的内置类型或你想在Action中加入更多参数，
直接修改既可，其他使用到这个Action的地方并不需要修改，因为Action是通过uri调用的，
uri中只是引用了Action对应的方法的名称，而与方法的参数无关。

2.7 Http请求、响应、Session、Cookie



2.7.1 程序代码

//对应apps\HttpInfo.java文件

import java.util.Locale;
import java.io.PrintWriter;
import com.douyu.main.Controller;

import com.douyu.http.HttpRequest;
import com.douyu.http.HttpResponse;
import com.douyu.http.HttpSession;
import com.douyu.http.Cookie;

@Controller
public class HttpInfo {
	public void index(HttpRequest request, HttpResponse response, PrintWriter out) {
		printHttpRequestInfo(request, out);

		Cookie[] cookies = request.getCookies();
		out.println("Cookie信息:");
		out.println("------------------------------------");
		//首次请求时为空
		if(cookies == null) {
			out.println("cookies = null");
		} else {
			for(Cookie c : cookies) {
				out.println("Cookie = "+c);
			}
		}
		Cookie cookie = new Cookie("MyCookie","is cool");
		//10秒钟后过期
		cookie.setMaxAge(10);
		response.addCookie(cookie);

		cookie = new Cookie("MyCookie2","is very cool");
		cookie.setMaxAge(10);
		response.addCookie(cookie);

		out.println();


		out.println("Http Session信息:");
		out.println("------------------------------------");
		HttpSession session = request.getSession(true);
		out.println("session id = "+session.getId());
		out.println("isNew      = "+session.isNew());
		Object counter = session.getAttribute("counter");
		if(counter == null) {
			out.println("counter    = 0");
			session.setAttribute("counter",1);
		} else {
			out.println("counter    = "+counter);
			session.setAttribute("counter",((Integer)counter).intValue()+1);
		}
	}

	private void printHttpRequestInfo(HttpRequest request, PrintWriter out) {
		out.println("Http请求参数信息:");
		out.println("------------------------------------");
		for(String paramName : request.getParameterNames()) {
			out.println("参数名: "+paramName+"  参数值: "+ request.getParameter(paramName));
		}
		out.println();

		out.println("Accept-Language请求头:");
		out.println("------------------------------------");
		for(Locale locale : request.getLocales())
			out.println("locale = "+locale);
		out.println();

		out.println("所有请求头:");
		out.println("------------------------------------");
		for(String headerName : request.getHeaderNames())
			out.println(headerName+": "+request.getHeader(headerName));

		out.println();
		out.println("其他与Http请求有关的信息:");
		out.println("------------------------------------");
		out.println("Protocol    = "+request.getProtocol());
		out.println("Method      = "+request.getMethod());
		out.println("QueryString = "+request.getQueryString());
		out.println("ServerName  = "+request.getServerName());
		out.println("ServerPort  = "+request.getServerPort());
		out.println("RemoteHost  = "+request.getRemoteHost());
		out.println("RemoteAddr  = "+request.getRemoteAddr());
		out.println("RemotePort  = "+request.getRemotePort());
		out.println("LocalName   = "+request.getLocalName());
		out.println("LocalAddr   = "+request.getLocalAddr());
		out.println("LocalPort   = "+request.getLocalPort());

		out.println();
	}
}

2.7.2 运行 HttpInfo


打开浏览器，输入 http://localhost:8000/HttpInfo?p1=123&p2=abc
结果类似这样:




2.7.3 程序代码说明

上面的代码演示了HttpRequest、HttpResponse、HttpSession、Cookie的普遍用法，
如果你熟悉Servlet，那么应该对上面出现的各类方法很熟悉，
这主要是因为HttpRequest接口是从以下两个Servlet规范中定义的接口改造而来的:
javax.servlet.ServletRequest
javax.servlet.http.HttpServletRequest

同样的，HttpResponse接口从下面两个Servlet规范中定义的接口改造而来：
javax.servlet.ServletResponse
javax.servlet.http.HttpServletResponse

另外，HttpSession接口对应 javax.servlet.http.HttpSession接口
而Cookie类对应 javax.servlet.http.Cookie类

除了这些对应关系之外，还删除了很多在Douyu看来没有必要使用的方法，
一些方法的返回值也做了修成，比如原来返回java.util.Enumeration类型的，
现在变成了字符串数组或是java.util.List，这样可以运用for each循环来简化编程。

为什么要仿照Servlet规范中定义的接口呢？
除了能让原来熟悉Servlet的程序员轻松过度到Douyu外，
最主要原因是Http协议是定死的，
实现了Http协议的服务器能向用户提供的有关http的API大多数都是大同小异的，
玩不出什么另类的花样，而Servlet规范中定义的http相关接口算是比较成熟、比较完备了，
所以直接仿照或改造Servlet原有API是很合理的。


Douyu的后续版本还会对com.douyu.http包中定义的接口或类进行完善。

小技巧:
也可以通过com.douyu.main.Context接口中定义的如下方法
来获得HttpRequest、HttpResponse、HttpSession的实现类的实例引用:

public HttpRequest getHttpRequest();
public HttpResponse getHttpResponse();
public HttpSession getHttpSession();
public HttpSession getHttpSession(boolean create);

2.8 Douyu的权限模型


按前面各小节的惯例，还是从简单的例子开始。

假定你接到上级任务要开发一个"员工薪水管理模块"，要面对这样的需求:
======================================================================

员工分为3类:
employee1
employee2
manager

还有一个特殊的员工hr，你可以把他想像成是公司的最高领导，
由他给下面的员工发钱，只有他才能调整其他员工的薪水。


另外，员工employee1只能查看他自己的薪水，他不能查看别人的薪水，
也不能修改自己的或别人的薪水；

同样，员工employee2也只能查看他自己的薪水，他不能查看别人的薪水，
也不能修改自己的或别人的薪水；

员工manager有点特殊，他除了能查看自己的薪水外还能查看employee1与employee2的薪水，
但是他同样不能修改自己的或别人的薪水。

======================================================================

了解了需求后开始编码吧，
不过为了让代码尽可能的简单，这里不涉及数据库，也不涉及复杂的加密操作，
目的是为了把重心放在Douyu的权限模型上，否则会喧宾夺主。


2.8.1 程序代码


(注: 事先不必过于追究代码实现细节，有个表面印象既可，2.8.3节会有详述)

//对应apps\permission\Login.html文件

<HTML>
<HEAD><TITLE>用户登录</TITLE></HEAD>
<BODY>
用户登录:
<FORM METHOD=POST ACTION="/permission.Login/check">
	用户:<INPUT TYPE="text" NAME="name" VALUE="employee1"><br>
	密码:<INPUT TYPE="password" NAME="password" VALUE="1"><br>
	<INPUT TYPE="submit" VALUE="登录"> <INPUT TYPE="reset">
</FORM>
</BODY>
</HTML>

//对应apps\permission\Login.java文件

package permission;

import java.io.PrintWriter;
import java.util.HashMap;

import com.douyu.main.Context;
import com.douyu.main.Controller;

import com.douyu.security.PermissionAction;
import com.douyu.security.FieldPermission;
import com.douyu.security.FunctionPermission;

@Controller(checkPermission=false)
public class Login {
	//预定义了四个用户及其对应的密码
	HashMap<String,Integer> passwordMap = new HashMap<String,Integer>(4);
	{
		passwordMap.put("employee1",1);
		passwordMap.put("employee2",2);
		passwordMap.put("manager",3);
		passwordMap.put("hr",4);
	}

	//首先显示登录页面
	public void index(Context c) {
		c.out("permission/Login.html");
	}

	//接着检查用户名或密码是否正确，
	//如果检查通过了，再根据用户名来分配不同的权限操作，
	//最后显示薪水列表页面。
	public void check(Context c, String name, int password, PrintWriter out) {
		Integer correctPassword = passwordMap.get(name);
		if(correctPassword == null || correctPassword.intValue() != password) {
			out.println("用户名或密码不对");
			return;
		}

		//映射关系是: (类名--> (方法名 --> 权限操作))
		HashMap<String,HashMap<String,PermissionAction>> permissionActionMap =
		new HashMap<String,HashMap<String,PermissionAction>>();

		//映射关系是: 方法名-->权限操作
		HashMap<String,PermissionAction> map =
			new HashMap<String,PermissionAction>();

		//用户employee1只能查看自己的薪水
		if(name.equals("employee1")) {
			map.put("employee1_salary_field", FieldPermission.SHOW);
			map.put("employee2_salary_field", FieldPermission.HIDDEN);
			map.put("manager_salary_field", FieldPermission.HIDDEN);

			permissionActionMap.put("permission.SalaryForm", map);
		}
		//用户employee2也只能查看自己的薪水
		else if(name.equals("employee2")) {
			map.put("employee1_salary_field", FieldPermission.HIDDEN);
			map.put("employee2_salary_field", FieldPermission.SHOW);
			map.put("manager_salary_field", FieldPermission.HIDDEN);

			permissionActionMap.put("permission.SalaryForm", map);
		}
		//用户manager除了能查看自己的薪水外，
		//还能查看employee1与employee2的薪水，
		//但是他不能修成自己的或别人的薪水
		else if(name.equals("manager")) {
			map.put("employee1_salary_field", FieldPermission.SHOW);
			map.put("employee2_salary_field", FieldPermission.SHOW);
			map.put("manager_salary_field", FieldPermission.SHOW);

			permissionActionMap.put("permission.SalaryForm", map);
		}
		//hr代表一个更抽象的用户，
		//他既能查看别人的薪水，也能修改别人的薪水。
		else if(name.equals("hr")) {
			map.put("employee1_salary_field", FieldPermission.EDIT);
			map.put("employee2_salary_field", FieldPermission.EDIT);
			map.put("manager_salary_field", FieldPermission.EDIT);

			permissionActionMap.put("permission.SalaryForm", map);

			map = new HashMap<String, PermissionAction>();
			map.put("modifySalary", FunctionPermission.ALLOW);
			permissionActionMap.put("permission.SalaryController", map);
		}

		//把有关权限操作的信息存储到运行期间的上下文环境中
		c.setPermissionActionMap(permissionActionMap);
		
		//显示薪水列表页面
		c.out("permission/SalaryForm.html", new SalaryForm());
	}
}

//对应apps\permission\SalaryForm.html文件

<HTML><HEAD><TITLE>公司员工薪水列表</TITLE>
</HEAD>
<BODY>
${message}

公司员工薪水列表 ( 单位: RMB/月 )
<FORM METHOD=POST ACTION="/permission.SalaryController/modifySalary">
<TABLE border=1>

<TR>
	<TD>employee1:<INPUT TYPE="text" NAME="employee1_salary" VALUE="${employee1_salary}" ${employee1_salary_disabled}></TD>
</TR>

<TR>
	<TD>employee2:<INPUT TYPE="text" NAME="employee2_salary" VALUE="${employee2_salary}" ${employee2_salary_disabled}></TD>
</TR>

<TR>
	<TD>manager&nbsp;&nbsp;:<INPUT TYPE="text" NAME="manager_salary" VALUE="${manager_salary}" ${manager_salary_disabled}></TD>
</TR>

</TABLE>
<INPUT TYPE="submit" value="修改薪水" ${modify_salary_disabled}>
<INPUT TYPE="reset">
</FORM>

<FORM METHOD=POST ACTION="/permission.Logout">
<INPUT TYPE="submit" value="退出">
</FORM>
</BODY>
</HTML>

//对应apps\permission\SalaryForm.java文件

package permission;

import com.douyu.main.Form;
import com.douyu.main.Setter;
import com.douyu.main.Guard;

import com.douyu.security.PermissionAction;
import com.douyu.security.FieldPermission;
import com.douyu.security.FunctionPermission;

//这个类与公司员工薪水列表对应，
//你也可以把它看成是数据库中的一张员工薪水表，
//用来存放每类员工的薪水.
@Form
public class SalaryForm {
	String employee1_salary = "5000";
	String employee1_salary_disabled = ""; //""表示可以编辑employee1_salary字段

	String employee2_salary = "6000";
	String employee2_salary_disabled = "";
	
	String manager_salary = "10000";
	String manager_salary_disabled = "";

	//SalaryForm类可以作为任何Action方法参数的类型，
	//通过这个Setter方法就可以自动生成一个SalaryForm类的实例。
	@Setter
	public void init(String employee1_salary,
		String employee2_salary, String manager_salary) {

		if(employee1_salary != null) 
			this.employee1_salary = employee1_salary;
		if(employee2_salary != null) 
			this.employee2_salary = employee2_salary;
		if(manager_salary != null) 
			this.manager_salary = manager_salary;
	}

	//对应员工薪水表单中的employee1_salary字段
	@Guard
	public void employee1_salary_field(PermissionAction pa) {
		if(pa != FieldPermission.EDIT) {
			employee1_salary_disabled = "disabled";
		}
		
		//没有为employee1_salary字段赋权限(pa=null)或权限为隐藏时，
		//都不允许查看用户employee1的薪水
		if(pa == null || pa == FieldPermission.HIDDEN) {
			employee1_salary = "";
		}
	}

	//对应员工薪水表单中的employee2_salary字段
	@Guard
	public void employee2_salary_field(PermissionAction pa) {
		if(pa != FieldPermission.EDIT) {
			employee2_salary_disabled = "disabled";
		}

		if(pa == null || pa == FieldPermission.HIDDEN) {
			employee2_salary = "";
		}
	}

	//对应员工薪水表单中的manage_salary字段
	@Guard
	public void manager_salary_field(PermissionAction pa) {
		if(pa != FieldPermission.EDIT) {
			manager_salary_disabled = "disabled";
		}

		if(pa == null || pa == FieldPermission.HIDDEN) {
			manager_salary = "";
		}
	}
	
	//对应员工薪水表单中的"修改薪水"按钮，
	//同时与SalaryController控制器类的"modifySalary"方法关联，
	//按钮的权限操作类型由对应的控制器类的Action方法决定，
	//如果不能调用Action方法也就意味着不能点击按钮或按钮将被隐藏(这取决于你的设计选择)
	@Guard(
		controller = SalaryController.class,
		controllerAction = "modifySalary"
	)
	public void modify_salary_button(PermissionAction pa) {
		if(pa != FunctionPermission.ALLOW)
			modify_salary_disabled = "disabled";
	}

	String modify_salary_disabled = "";

	String message = ""; //比如类似"薪水已修改"这样的提示消息
}

//对应apps\permission\SalaryController.java文件

package permission;

import com.douyu.main.Context;
import com.douyu.main.Controller;

@Controller
public class SalaryController {

	public void modifySalary(Context c, SalaryForm sf) {
		sf.message = "薪水已修改<br><br>";
		c.out("permission/SalaryForm.html", sf);
	}
}

//对应apps\permission\Logout.java文件

package permission;

import com.douyu.main.Context;
import com.douyu.main.Controller;

@Controller(checkPermission=false)
public class Logout {
	public void index(Context c) {
		//在运行期间的上下文环境中把有关权限操作的信息清除
		c.setPermissionActionMap(null);
		//重新显示登录页面
		c.out("permission/Login.html");
	}
}

2.8.2 运行


如果Douyu服务器正在运行，请先连按两次 Ctrl+C 键停止服务器，
然后打开conf\server.java文件，
将配置参数checkPermission设为 checkPermission = true,
这样就启用Douyu服务器的权限管理模块了,
保存文件后再重新启动服务器。
(注：目前暂时不支持"修改服务器配置文件后自动装载"这样的功能，你必须手工重新启动服务器)


打开浏览器，输入 http://localhost:8000/permission.Login
结果类似这样:



为了方便测试，默认情况下是用户employee1，点"登录"按钮后如下:


从上图可以看到，employee1只能查看自己的薪水，
并且所有文本框都是不可编辑的，"修改薪水"按钮是无效的，
接着点"退出"按钮回到登录页面，
用户换成employee2，密码是2，点"登录"按钮后如下:


从上图可以看到，employee2也只能查看自己的薪水，
并且所有文本框都是不可编辑的，"修改薪水"按钮是无效的，
接着点"退出"按钮回到登录页面，
用户换成manager，密码是3，点"登录"按钮后如下:


从上图可以看到，manager能看到他自己的薪水，也能看到employee1与employee2的薪水，
但是所有文本框都是不可编辑的，"修改薪水"按钮也是无效的，
接着点"退出"按钮回到登录页面，
用户换成hr，密码是4，点"登录"按钮后如下:


从上图可以看到，hr能看到manager、employee1与employee2的薪水，
现在所有文本框都是可编辑的了，"修改薪水"按钮也可以点击了，
随意修改任何一个文本框中的值，比如把manager的薪水改为12000，
点"修改薪水"按钮后如下:



接着点"退出"按钮回到登录页面，

现在在浏览器中尝试输入:
http://localhost:8000/permission.SalaryController/modifySalary
将会得到一个403(禁止访问)错误,如下图所示:


因为用户hr已经退出了，即使他有"修改薪水"的权限也不能在没有登录或退出时修改薪水。

在浏览器中重新输入 http://localhost:8000/permission.Login
用户换成manager，密码是3，点"登录"按钮，登录成功后，先别点"退出"按钮，
先尝试在浏览器输入:
http://localhost:8000/permission.SalaryController/modifySalary?manager_salary=100000，
结果还是一样，用户manager会收到403(禁止访问)错误信息，虽然用户manager已经登录成功了，
但是他没有"修改薪水"的权限，系统不允许他绕过表单界面"修改薪水"。



2.8.3 程序代码说明


2.8.3.1 最基本的权限分类

先抛开具体的业务逻辑(或业务规则)，怎样才能控制一个对象的行为呢？
对象是一个很宽泛的概念，比如上例中出现的薪水表单和薪水控制器都可以称为一个对象。
从Java语言的角度来看，对象本质上就是某个Java类在运行期间生成的实例，
而一个类通常由方法和字段组成(这里的"方法"特指静态方法和非静态方法，"字段"特指实例变量和类变量)，
只要控制了方法的调用权限和字段的获取更新权限也就在总体上控制了对象的行为。

方法的调用权限、字段的获取更新权限就是从Java语言层面抽取出来的最基本单位，
Douyu的权限模型为此分别建立了两个类:

com.douyu.security.FunctionPermission;
com.douyu.security.FieldPermission;

为什么不叫MethodPermission而叫FunctionPermission呢?
因为"方法"也可以叫做"函数"，一个"方法"通常实现了某类功能，
比如上例中的SalaryController.modifySalary方法就实现了修改员工薪水的功能，
所以"Function"比"Method"更具有实际意义，也更容易理解。

FunctionPermission与FieldPermission都是 com.douyu.security.Permission 这个抽象类的子类，
com.douyu.security.Permission 目前并没有什么特别的地方。



2.8.3.2 权限操作

权限只是一个更高级别的概念，还需要一个"权限操作"的概念来进一步细化，
比如可以把SalaryController.modifySalary方法抽象成一个FunctionPermission(功能权限)，
要么允许你调用这个方法，要么禁止你调用这个方法，
所以功能权限的"权限操作"类型只能分为两类: 允许 和 禁止。

类似的，上例中出现的：
employee1_salary_field
employee2_salary_field
manager_salary_field
都可以抽象成一个FieldPermission(字段权限)，
用户employee1、employee2都只能查看他们自己的薪水，
用户manager可以查自己的和别人的薪水，
而hr可以同时查看和修改别人的薪水。

这就意味着字段权限的"权限操作"类型不是固定的，
可以是可查看的，也可以是可修改的，还可以隐藏，当然还有我没想到的其他分类。

在Douyu的权限模型中定义了一个叫 com.douyu.security.PermissionAction 的接口来对"权限操作"进行建模。
PermissionAction这个名字来源与Java平台类库中的抽象类: java.security.Permission，
java.security.Permission包含了String getActions()方法，
并且每个java.security.Permission子类都有零个或多个权限操作类型。

com.douyu.security.PermissionAction接口很简单，
目前只定义了两个方法:

public String getLabel();
public String getName();

Label和Name通常都是一样的，除非你要提供不同的本地化信息时Label才有必要跟Name不同，
比如一个字段权限定义了一个叫做"编辑"的权限操作类型，
那么你可以为"编辑"这样的权限操作类型定义一个类来实现PermissionAction接口，

public class EditPA implements com.douyu.security.PermissionAction {
	public String getLabel() {
		return "编辑";
	}
	public String getName() {
		return "edit";
	}
}

2.8.3.3 Douyu的权限模型中内置的权限操作类型


在com.douyu.security.FunctionPermission类中定义了两个权限操作类型:

FunctionPermission.ALLOW
FunctionPermission.FORBID

其中的FunctionPermission.ALLOW已在上面的Login.check方法的第四个if语句中用到了，
如下:

		else if(name.equals("hr")) {
			.......
			map = new HashMap<String, PermissionAction>();
			map.put("modifySalary", FunctionPermission.ALLOW);
			.......
		}

意思就是允许用户hr调用modifySalary方法，
如果没有明确说明是否允许调用某一个方法，那么实际的语义就是不允许，
比如Login.check方法的前3个if语句都没有显示调用:
map.put("modifySalary", FunctionPermission.ALLOW)或
map.put("modifySalary", FunctionPermission.FORBID);
那么实际上等于：map.put("modifySalary", FunctionPermission.FORBID)，
不过Douyu的内部实现是把null当成FunctionPermission.FORBID看待的，
当Douyu的内部实现调用map.get("modifySalary")时，
如果返回null或FunctionPermission.FORBID，寻么将禁止调用modifySalary方法，
只有明确返回FunctionPermission.ALLOW时才允许调用modifySalary方法。


特别值得注意的是，FunctionPermission类定义的两个权限操作类型ALLOW与FORBID目前是固定的，
你不能替换掉他们，比如你定义了一个新的叫"MyPermissionAction"的权限操作类型，
你不能用它来控制某一个功能权限是否被允许，比如像这样:
map.put("modifySalary", MyPermissionAction)
虽然你的MyPermissionAction正确实现了PermissionAction接口,但是上面的代码就不起作用。

当然，以后的Douyu实现版本可能会去掉这个限制，不过目前看不出有多大必要，
因为一个方法通常只可能包含两种权限操作类型:允许 和 禁止。



在com.douyu.security.FieldPermission类中预定义了三个权限操作类型:

FieldPermission.EDIT
FieldPermission.SHOW
FieldPermission.HIDDEN

光从字面看就很容易理解了，EDIT除了可查看外，还能编辑修改，SHOW只能查看，HIDDEN表示不能查看。
当然，你可以扩充其他的权限操作类型，你也完全可以忽略上面的三个预定义类型，
不过，当你使用了自己定义的类型时最好把它声明为"public static final"的类型常量，
这样不但节省了内存空间，你还可以直接使用"=="或"!="号来判断两个PermissionAction接口实例是否相等。
上面例子中的SalaryForm类就大量使用了"=="或"!="号。


2.8.3.4 方法名与权限操作类型的映射

在上面的Login.check方法中你可能注意到了，用到了两级 HashMap：

HashMap<String,HashMap<String,PermissionAction>> permissionActionMap =
		new HashMap<String,HashMap<String,PermissionAction>>();

最内层是： HashMap<String,PermissionAction>
以方法名为Key，以具体的权限操作类型常量为值，如下所示:

	map.put("employee1_salary_field", FieldPermission.SHOW);
	map.put("employee2_salary_field", FieldPermission.HIDDEN);
	map.put("manager_salary_field", FieldPermission.HIDDEN);

值得注意的是employee1_salary_field、employee2_salary_field与manager_salary_field
并不是SalaryForm类中真正的字段(真正的字段是:employee1_salary、employee2_salary与manager_salary)
实际上他们是SalaryForm类中的一种特殊方法，
这些方法标有@Guard， 而且只有一个参数"PermissionAction pa"，
这两个特征就告诉了编译器这一类方法需要特别对待，@Guard 就像一个尽职的守卫，
他在小心的照看着一件宝物(就是那个真正的字段)，
当你要使用这件宝物时你必需亮出你的证件(PermissionAction)，
如果你是国王才会给你真品，只是一般官员给件赝品看看就行了，要是来打劫的直接枪毙。

通过这样的抽象，对任何字段的存取修改权限都可以通过定义如下类型的方法来实现:

@Guard
public 返回类型 方法名(PermissionAction 参数名) {
	//检查权限操作类型的代码放在这里
}

其中@Guard、public、PermissionAction是必需的，其他地方没有具体要求。

解决了字段权限问题后，就来看看如何确定功能权限。

控制器类中的所有Action对应的方法都可以抽象成一个功能权限，
比如上例中的SalaryController.modifySalary方法就是一个功能权限。

不过光有@Guard方法名和Action方法名还不足以区分不同的权限操作，
因为不同的两个类可能定义了同名的方法，解决问题的办法是引入类名，
这样就产生了两级映射:(类名--> (方法名 --> 权限操作))

Login.check方法中的如下代码完美演示了这样的映射关系:

		else if(name.equals("hr")) {
			map.put("employee1_salary_field", FieldPermission.EDIT);
			map.put("employee2_salary_field", FieldPermission.EDIT);
			map.put("manager_salary_field", FieldPermission.EDIT);

			permissionActionMap.put("permission.SalaryForm", map);

			map = new HashMap<String, PermissionAction>();
			map.put("modifySalary", FunctionPermission.ALLOW);
			permissionActionMap.put("permission.SalaryController", map);
		}

else if块中的代码第一部份是给用户hr分配permission.SalaryForm类中的字段权限，
而第二部份是给用户hr分配permission.SalaryController类中的功能权限。


2.8.3.5 联姻Action与表单按钮(或其他能激活Action的元素)

先把apps\permission\SalaryForm.java文件中的modify_salary_button方法注释掉

	/*
	@Guard(
		controller = SalaryController.class,
		controllerAction = "modifySalary"
	)
	public void modify_salary_button(PermissionAction pa) {
		if(pa != FunctionPermission.ALLOW)
			modify_salary_disabled = "disabled";
	}
	*/

在浏览器中输入 http://localhost:8000/permission.Login
直接点"登录"按钮后如下图:


这时"修改薪水"按钮不是灰色了，
点击一下它你将会得到一个403(禁止访问)错误。

还好你已不是第一次使用这个"系统",你肯定已知道employee1没有权限修改薪水，
这都可以理解。如果你在正式的商业产品中也采用了这样的方式，
你的很多客户很可能会向你报告Bug："我点了修改按钮怎么老是出来个奇怪的页面?"，
然后你得苦口婆心的解释这不是个Bug，
把责任全推给一个虚拟的员工："这是XXX写的蹩脚的代码"。

显然，这样的界面设计并不友好，给用户带来了糟糕的用户体验，
更得体的做法是：要控制的按钮或其他元素如果在隐藏后不影响界面布局，
那么就尽可能的隐藏掉，否则就把它禁用(比如变成灰色)。


Html界面中的按钮或链接通常都会触发一个Action，
在Douyu的权限模型中很容易将这两者关联起来，
例如SalaryForm类中的modify_salary_button方法:

	@Guard(
		controller = SalaryController.class,
		controllerAction = "modifySalary"
	)
	public void modify_salary_button(PermissionAction pa) {
		if(pa != FunctionPermission.ALLOW)
			modify_salary_disabled = "disabled";
	}

同样是采用@Guard 来标识，只不过比字段权限多了两个属性参数，
属性controller用来指向一个java.lang.Class实例，
这个Class实例表示一个具体的控制器类。
属性controllerAction是字符串类型，表示对应的控制器类中的某个Action方法名。

如果有很多个这样的@Guard按钮都是关联到同一个控制器类，只是Action方法名不同，
那么可以在@Form中指定属性controller的值，
这样如果一个@Guard按钮没有指定属性controller，那么将使用@Form中的值
下面的伪代码演示了基本的用法:

@Form(controller = MyController.class)
public class MyForm {
	@Guard(controllerAction = "action1")
	public void button1(PermissionAction pa) {
	}

	@Guard(controllerAction = "action2")
	public void button2(PermissionAction pa) {
	}
}

另外，@Guard按钮对应的方法名不必放在"(方法名 --> 权限操作)"映射中，
你无需显示为@Guard按钮分配权限，它会自动获取与之相关的Action的权限，
比如在上面的例子中，只有用户hr能修改薪水，
也就是说只有用户hr能调用SalaryController类的modifySalary方法，
而modifySalary方法与SalaryForm类中的modify_salary_button相关联，
所以用户hr进入公司员工薪水列表界面时"修改薪水"按钮是有效的，
而其他用户进入时"修改薪水"按钮都变成了灰色。


2.8.3.6 checkPermission开关


服务器配置文件conf\server.java，
@Form 与 @Guard
@Controller 与 从未出现过的com.douyu.main.Action(也是一个Annotation，用来标注Action方法)
都可以设置checkPermission参数，
在conf\server.java中设置的checkPermission是总开关，如果它为true就启用权限模块，
否则就禁用权限模块，
@Form与@Controller的checkPermission是第二级开关，把它们的checkPermission设为false时，
将不会对它们所包含的@Guard或@Action进行权限检查，

@Guard或@Action的checkPermission是最后一级开关，只有前两级开关都开通后它们才有效。

比如前面的例子中的Login和Logout这两个类的@Controller的checkPermission都是false，
这样就不进行权限检查了，任何人都可以调用它们的Action方法，这正是实际情况所需要的，
因为任何人在获得其他权限前必需首先获得登录权限。


2.8.3.7 com.douyu.main.Context接口中与权限有关的方法

//这个方法在Login.check方法中已使用过了，
//就是在上下文中保存 "(类名--> (方法名 --> 权限操作))"这样的映射关系
public void setPermissionActionMap(
	Map<String,? extends Map<String,PermissionAction>> permissionActionMap);

//这个方法主要是提供给Douyu的内部实现使用的，
//不过用户有需要时也可用它来获取之前设置过的信息
public Map<String,? extends Map<String,PermissionAction>> getPermissionActionMap();

2.8.4 还可以走得更远

虽然2.8.3节给出的例子过于简单了，甚至可以说不具有实际意义，
不过它还是恰到好处的展示了Douyu权限模型的核心理念:基于字段和方法实现基本的权限模型。

Douyu的权限模型并不直接与角色、用户、用户组、资源分类等等这些常见的概念挂钩，
也不依赖于特定的数据库表，但是并不妨碍你把Douyu的权限模型对应到传统的权限模型上。

比如你可以建一张类名表，用来保存与@Form、@Controller相关的类名，
然后建一张方法名称表用来保存与@Guard或@Action相关的方法名(不同类的同名方法都可存放在这里)，
再建一张很小的权限操作类型表。

从这三张表中各取一条记录就组合成了一个"(类名--> (方法名 --> 权限操作))"映射，
每个映射既可以分配给角色也可以分配给用户或用户组，
当你用具体的用户登录系统时，如果用户属于某个用户组，这个用户组被赋予了某种角色，
那么这个用户最后的权限就是三种权限的并集：
用户最后的权限 = 用户自己特有的权限 + 用户所属用户组的权限
+ 用户所属用户组的角色的权限

最繁琐的地方在于如何制作一个权限配置界面？权限的粒度如何把握？
通常来讲功能权限是比较粗的一级，而字段权限是比较细的一级，
功能权限在正式的产品项目中都是基本的配备，而字段权限并不多见，
只在一些信息很敏感的表单中会设置字段权限，否则要是每张表每个字段都设置的话，
权限配置工作会是一件很累人的差事。

com.douyu.main.Context接口中还定义了两个方法:

public List<Permission> getPermissionList();
public Map<String,Permission> getPermissionMap(); //以类名为key

当你调用其中任何一个方法时都会启动编译器对apps目录中的所有Java源文件进行分析，
然后抽取出与@Form、@Controller相关的类名及与@Guard或@Action相关的方法名，
并生成下面的四个Permission子类的实例:

com.douyu.security.FormPermission
com.douyu.security.ControllerPermission
com.douyu.security.FieldPermission
com.douyu.security.FunctionPermission

FormPermission类的getFieldPermissionList()方法可以获得它所包含的FieldPermission
ControllerPermission类的getFunctionPermissionList()方法可以获得它所包含的FunctionPermission

另外，@Form、@Controller与@Guard、@Action都有label和name属性，
如果有需要你可以设置它们，这两个属性可能在生成权限配置菜单时有用，
比如如果权限配置菜单采用下拉框的形式，那么label可以作为前台的文本显示，而name是后台的实际值。
name属性通常没必要指定，目前的内部实现中未使用这个name属性值。

com.douyu.security.Permission类定义了两个方法

public String getLabel(); //获得label属性值，未设置时要么是简单类名(不含包名)要么是方法名
public String getName();  //要么是类名(含包名)要么是方法名(取决于Permission的类型)

下面是一个综合演示例子:

//对应apps\permission\PermissionList.java文件

package permission;

import com.douyu.main.*;
import com.douyu.security.*;

import java.io.PrintWriter;

@Controller(label="权限列表",checkPermission=false)
public class PermissionList {
	@Action(label="打印权限列表")
	public void index(Context c, PrintWriter out) {
		for(Permission p : c.getPermissionList()) {
			out.println(p);

			if(p instanceof FormPermission)
				for(Permission f: ((FormPermission)p).getFieldPermissionList())
					out.println("\t"+f);
			else if(p instanceof ControllerPermission)
				for(Permission f: ((ControllerPermission)p).getFunctionPermissionList())
					out.println("\t"+f);

			out.println();
		}
	}
}

在浏览器中输入:
http://localhost:8000/permission.PermissionList

可以看到这样的结果:

com.douyu.security.ControllerPermission[label=WhatTime, name=WhatTime]
	com.douyu.security.FunctionPermission[label=index, name=index]

com.douyu.security.ControllerPermission[label=SupernaturalAction, name=SupernaturalAction]
	com.douyu.security.FunctionPermission[label=index, name=index]
	com.douyu.security.FunctionPermission[label=showUser, name=showUser]

com.douyu.security.FormPermission[label=SalaryForm, name=permission.SalaryForm]
	com.douyu.security.FieldPermission[label=employee1_salary_field, name=employee1_salary_field]
	com.douyu.security.FieldPermission[label=employee2_salary_field, name=employee2_salary_field]
	com.douyu.security.FieldPermission[label=manager_salary_field, name=manager_salary_field]
	com.douyu.security.FieldPermission[label=modify_salary_button, name=modify_salary_button]

com.douyu.security.ControllerPermission[label=SalaryController, name=permission.SalaryController]
	com.douyu.security.FunctionPermission[label=modifySalary, name=modifySalary]

com.douyu.security.ControllerPermission[label=权限列表, name=permission.PermissionList]
	com.douyu.security.FunctionPermission[label=打印权限列表, name=index]

com.douyu.security.ControllerPermission[label=Logout, name=permission.Logout]
	com.douyu.security.FunctionPermission[label=index, name=index]

com.douyu.security.ControllerPermission[label=Login, name=permission.Login]
	com.douyu.security.FunctionPermission[label=index, name=index]
	com.douyu.security.FunctionPermission[label=check, name=check]

com.douyu.security.ControllerPermission[label=HttpInfo, name=HttpInfo]
	com.douyu.security.FunctionPermission[label=index, name=index]

com.douyu.security.ControllerPermission[label=HelloWorld, name=HelloWorld]
	com.douyu.security.FunctionPermission[label=index, name=index]

com.douyu.security.ControllerPermission[label=FileUpload, name=FileUpload]
	com.douyu.security.FunctionPermission[label=index, name=index]
	com.douyu.security.FunctionPermission[label=upload, name=upload]

特别提醒:
public List<Permission> getPermissionList();
public Map<String,Permission> getPermissionMap();
这两个方法是很耗时的操作，不应该在软件正式运行时调用，
通常只在开发最后阶段为了辅助生成权限菜单时使用，
通过遍历List<Permission>，可以获得类名或方法名，运用这些信息你可以做些有用的事，
比如生成批量的sql Insert语句，然后把这些Insert语句导入数据库中。

2.9 ORM能达到多大程度的自动化?


2.9.1 Douyu的ORM


Douyu的ORM(对象/关系映射)不同于Hibernate、Ibatis、Rails的ActiveRecord，
使用Douyu的ORM，你无需编写任何模型类。

Douyu的ORM比Rails的ActiveRecord还要简单，Rails的ActiveRecord虽然号称是业界最简单的ORM框架了，
但是你还是得写一个模型类去继承ActiveRecord::Base，它还是需要你去声明表间的关联关系，
那些恼人的has_one, has_many......很容易把你搞得一団浆糊，
如果你有Hibernate的使用经验，编写过xml格式的表间关联关系映射，那更是一场噩梦。

Douyu认为: 只要关系数据库还存在，
只要Oracle、DB2、SQL Server、MySQL这类主流的关系数据库还占据统治地位的时候，
只要你的系统用到了关系数据库，那么"以关系数据库为中心的设计思想"并不过时，
反而更容易让ORM走上自动化的道路。

"自动化"这个概念不同人有不同的理解，
ORM自动化到底是个什么东西? ORM能达到多大程度的自动化？


先来回答第一个问题: ORM自动化到底是个什么东西?

====================================================================
因为Douyu是用Java语言开发的，Douyu的ORM是基于JDBC规范来实现的，
在Douyu看来，要实现ORM自动化，首先必需把与数据库打交道的那一层(JDBC API)屏蔽掉，
接着应用服务器或其他ORM框架在运行时应该维护一个抽象的模型层，
模型层维护了很多模型类，这些模型类对应数据库中的表(或者数据库包含的其他对象(如视图、存储过程)),
并且这些模型类是根据JDBC API提供的元数据自动生成的，开发人员无需关心模型类的生成细节，
模型层还必需支持跨数据库的事务、必需自动维护表间的关联关系，必需自动维护表中定义的各种约束。

开发人员使用模型层提供的模型类就像是使用自己编写的模型类一样，
直接使用import语句来导入模型层提供的模型类。
====================================================================


给出了"ORM自动化"的概念后，再来解释:

为什么说"以关系数据库为中心的设计思想"并不过时，反而更容易让ORM走上自动化的道路？

现在的流行趋势是把"以关系数据库为中心的设计思想"当成是一种过时的设计思想，往往对之嗤之以鼻，
认为先按面向对象思想设计出模型类然后再生成关系表更加合理。
其实这是本未倒置，一旦模型类由开发人员编写，那就变成了一种手工劳动，根本就谈不上自动化，
而且也不利于开发人员与DBA的分工协作；再者用Java语言编写模型类比用SQL写建表脚本更复杂，
比如你用程序语言如何描述字段是否为null，如果字段是数字类型，如何用程序语言描述精度和刻度，
当然还有很多类似这样的字段约束，虽然程序语言都可以实现这样的功能，
但是实现起来不会比专用的SQL语句简单。

另外这种先设计模型类再生成关系表的设计思想也不能充分利用关系数据库的专有特性，
比如在Oracle中我想建个表，这个表必须放到不同的表空间中，
还需要设置不同的存储参数以及块空间管理参数。
这些事通常是DBA擅长的，开发人员没有精力、也没有时间去学习不同数据库的专有特性。

面向对象的设计思想跟关系模型也不同，关系模型比面向对象的设计思想更简单，
两个表是否有关系，只要一个主键加一个外键就能说清楚了，
而用面向对象的设计思想设计出来的类你必须理清所有的继承关系、实现了哪些接口，
然后再借助复杂的ORM框架分析你的类结构，最后才生成SQL语句。

如果我们回归到当初，拥抱"以关系数据库为中心的设计思想"，
那么让DBA折腾数据库去吧，开发人员先来喝杯咖啡，坐等开工。
(当然，如果你也是数据库高手，你可以让老板追加薪水，因为你把DBA的活也干了)

当数据库表设计完后，就可以充分利用Douyu这样的新型开发平台提供的服务了，
Douyu在运行期间维护一个模型层，
开发人员可以在自已编写的任何源代码中直接引用模型层提供的模型类，
也无需事先编译源代码，刷新一下浏览器就能查看运行结果。


如果你对这样的解释还不满意，那么接下来的章节就是为你准备的，
同时也间接回答了这个问题: ORM能达到多大程度的自动化？





2.9.2 基本的单表CRUD操作


2.9.2.1 程序代码

//对应apps\sql\Crud.java文件

package sql;

import com.douyu.main.Context;
import com.douyu.main.Controller;

import com.douyu.sql.Rows;

import sql.table.mysql.Pet;

@Controller
public class Crud {
	public void index(Context c, java.io.PrintWriter out) {
		int middle = 0;
		out.println("增加5条宠物");
		for(int i=1; i<=5; i++) {
			Pet pet = new Pet();
			pet.name("pet"+i);
			pet.age(i);
			c.insert(pet);

			if(i == 3) middle = pet.id(); //id值自动获取
			out.println("insert pet: id = "+pet.id()+" name = "+pet.name()+" age = "+pet.age());
		}

		out.println();

		out.println("查找中间那条宠物");
		Pet pet = new Pet();
		pet.id(middle);
		c.select(pet);
		out.println("select pet: id = "+pet.id()+" name = "+pet.name()+" age = "+pet.age());
		out.println();


		out.println("更新中间那条宠物的名子");
		pet.name("MyPet");
		c.update(pet);
		out.println("update pet: id = "+pet.id()+" name = "+pet.name()+" age = "+pet.age());
		out.println();


		out.println("删除中间那条宠物");
		out.println("delete pet: id = "+pet.id()+" name = "+pet.name()+" age = "+pet.age());
		out.println();
		c.delete(pet);


		out.println("把小于3岁的宠物的年龄都改成3岁");
		pet = new Pet();
		pet.age(3);
		c.update(pet,"age<3"); //与c.update(pet,"age<?",3)相同


		Rows<Pet> rows = new Rows<Pet>(Pet.class);
		c.select(rows);
		out.println("查看剩下的宠物:总共有 "+rows.count+" 条");
		for(Pet p : rows.rowList) {
			out.println("select pet: id = "+p.id()+" name = "+p.name()+" age = "+p.age());
		}
		out.println();


		out.println("删除年龄为5岁的宠物");
		c.delete(Pet.class, "age=5"); //与c.delete(Pet.class, "age=?", 5)相同

		
		rows.clear(); //清除上一次的数据
		c.select(rows);
		out.println("查看剩下的宠物:总共有 "+rows.count+" 条");
		for(Pet p : rows.rowList) {
			out.println("select pet: id = "+p.id()+" name = "+p.name()+" age = "+p.age());
		}
		out.println();


		out.println("查找前2条宠物");
		rows.clear();
		rows.offset = 1;
		rows.limit = 2;
		rows.orderBy = "name";
		c.select(rows);
		for(Pet p : rows.rowList) {
			out.println("select pet: id = "+p.id()+" name = "+p.name()+" age = "+p.age());
		}


		out.println("删除所有宠物");
		c.delete(Pet.class);
		
		rows.clear();
		c.select(rows);
		if(rows.count == 0) {
			out.println("查看剩下的宠物: 没有宠物了");
		}
	}
}

2.9.2.2 运行 Crud

这里使用的测试数据库是: MySQL Server 5.1，并且默认使用InnoDB Storage Engine。
对应的JDBC驱动是: mysql-connector-java-5.1.8 (支持最新的JDBC4.0规范)，

关于数据库的安装和配置请查看MySQL的参考手册。

因为个人精力有限，目前Douyu在开发时只在MySQL Server 5.1 与Oracle9i、Oracle11g上进行了测试，
并且采用方言机制对不同数据库进行了优化，其他数据库的支持在后续版本中会陆续加入。
不过就目前的情况来说，除了MySQL和Oracle之外，如果你使用别的数据库来测试下面的例子，
如果没有使用到一些数据库独有的特性，只要数据库驱动严格遵守JDBC规范，通常也是可用的，
也有可能存在问题，因为Douyu除了MySQL和Oracle之外没有对其他数据库进行测试。

另外，Douyu推荐你使用支持JDBC3.0、JDBC4.0规范的数据库驱动，
JDBC3.0规范已经出来9年了，各数据库厂商自带的数据库驱动一般都支持JDBC3.0规范。

1) 安装MySQL数据库驱动

可以到MySQL的官方网站下载数据库驱动(可能需要注册)，
下载下来解压后把里面的文件：
"mysql-connector-java-5.1.8-bin.jar"(文件名太长了，可以把它改为"mysql.jar")
copy到D:\Douyu\lib目录中("D:\Douyu"是Douyu服务器的安装目录，见:1.2节)
这样就完成数据库驱动的安装了，不需要别的特殊配置。


2) 在MySQL中建立一个数据库然后再建表

首先打开一个新的控制台进入:MySQL monitor
D:\>mysql -uroot -p
Enter password: ***
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 5
Server version: 5.1.38-community MySQL Community Server (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

然后建立一个名叫"douyu"的数据库(数据库名你可以任取，不过下文中都以"douyu"为参考)，
并选中"douyu"为当前数据库:
mysql> create database douyu;
Query OK, 1 row affected (0.19 sec)

mysql> use douyu;
Database changed
mysql>

最后把下面的SQL脚本copy到MySQL monitor中运行:
=============================================================
drop table if exists pet;

create table pet(
  id  int not null auto_increment,
  name varchar(50) not null,
  age int,
  primary key(id)
);
select * from pet;
=============================================================

结果像下面这样:
=============================================================
mysql> drop table if exists pet;
Query OK, 0 rows affected, 1 warning (0.03 sec)

mysql>
mysql> create table pet(
    ->   id  int not null auto_increment,
    ->   name varchar(50) not null,
    ->   age int,
    ->   primary key(id)
    -> );
Query OK, 0 rows affected (0.28 sec)

mysql> select * from pet;
Empty set (0.05 sec)

mysql>
=============================================================

到这里，你就像一个出色的DBA一样快速地完成了与数据库相关的工作。


3) 修改Douyu服务器的配置文件

如果Douyu服务器正在运行，请先连按两次 Ctrl+C 键停止服务器，
然后打开conf\server.java文件，
将配置参数 loadDatabases = false 改为 loadDatabases = true,
如果你是从2.8节顺序读到这里的，为了不出现http 403错误，
请将checkPermission = true 改为 checkPermission = false(或者注释掉也行)
然后像下面这样增加一个数据库配置项:

	databases = {
		//以下列出的只是常用选项，还有很多选项未在此处列出
		@Database (
			//是否在控制台打印运行期间生成的SQL语句(主要用于调试目的)
			printSQL = true,

			//是否输出模型类的源文件(主要用于开发参考目的，不要修改输出文件的内容)
			//outputJavaSourceFiles = true,

			//数据库方言(注释掉这个选项也可以，但是不能充分利用数据库的独有特性)
			dialect = SQLDialect.MySQL,

			//在Java源代码层使用的数据库名称，
			//如果同时配置了多个数据库，数据库名称不能相同
			name="mysql",

			//模型类所属包名，
			//包名是可以任取的，但建议不要跟你其他代码中的包名一样，
			//你可以通过import sql.table.mysql.*;这样的语句引用自动生成的模型类
			packageName="sql.table.mysql",

			//MySQL的java.sql.Driver接口实现类
			driver="com.mysql.jdbc.Driver",

			//MySQL特有的url语法，
			//其中的douyu是在MySQL中定义的数据库名，请根据你的实际情况修改
			url="jdbc:mysql://localhost/douyu",
			//用户名(通常是root)
			userName="请把你的用户名放在这里",
			//密码
			password="请把你的密码放在这里",
			
			//用tableNames参数告诉Douyu自动解析哪些表，
			//表名用逗号分隔，不区分大小写，如果是"*"号，那么自动解析所有表。
			tableNames="*"
		)
	}

注意，conf\server.java文件中的databases属性值是一个元素为@Database的数组，
还有，属性与属性之间，或者数组的元素与元素之间都是用逗号分隔的，
千万别敲入分号(可能是习惯性动作，比如我就常常这样)，
另外，最后一个属性或元素后面是不加逗号的，否则编译器会告诉你出现了语法错误。

保存已修改完的配置文件后再重新启动服务器,
如果一切顺利就会如下图所示:




4) 在浏览器中查看程序运行结果


打开浏览器，输入 http://localhost:8000/sql.Crud
第一次运行时，结果类似这样:


在服务器运行的控制台窗口会打印出运行期间生成的SQL语句:





2.9.2.3 程序代码说明

sql.table.mysql.Pet这个模型类是自动生成的，
其中"sql.table.mysql"是包名，
对应上一节在服务器conf\server.java文件中设置过的"packageName"属性值，
"Pet"当然就是模型类的类名了，对应数据库的pet表。
默认情况下把表名的第一字符转换成大写，其他字符转换成小写后就变成类名了，
而表中的列名全转换成小写后对应模型类的一个属性名，
属性值的Setter、Getter方法的名称也跟属性名一样。

比如pet表有name这一列，对应的属性名也是name,
通过pet.name(xxx)和pet.name()这样的方式来修改、获取name属性的值。

这样的命名风格完全是我自己的喜好，我不喜欢Rails中所提倡的表名加s的风格，
那只是以英语为母语的人的喜好，讲中文的人有时喜欢把所有中文的第一个拼音字母组合成表名，
有时甚至连讲英文的人也喜欢用user、user_info、user_table这样的命名方式来代替users这样的复数表名，
比如在MySQL或Oracle提供的系统表中都常见到这样的例子。

另外我也不喜欢setXXX或getXXX这样的风格，每次都要我输入多余的set、get前缀，
还要小心地把紧接在set、get前缀后的第一个字符变成大写，真是够烦的！

之所以采用这样的设计方案，除了个人喜好的原因外，
如果你使用了这样的默认风格还会获得小小的性能提升，
因为不用对表名进行额外的分析，也不用做多余的set、get字符串拼接转换。

当然了，如果你的喜好与我不同，喜欢传统风格，
还是可以满足你的要求的，
在后面讲到自定义数据库映射时(只需实现com.douyu.sql.DatabaseMapping接口)，
你不但可以自定义表名跟类名的映射，还可以自定义与表列名相关的属性名、Setter、Getter方法，
还能注册属性、SQL事件监听器。


sql.table.mysql.Pet这个模型类没有什么特别的地方，
没有继承任何类，也没有实现任何接口，
只包含一些与表列名相关的属性名及Setter、Getter方法。

四种SQL DML语句(INSERT、UPDATE、DELETE、SELECT)
分别对应com.douyu.main.Context接口中定义的如下方法(目前与SQL相关的操作也只有这些方法):

public boolean insert(Object entity);

public boolean update(Object entity);
public boolean update(Object entity, String where, Object... params);

public boolean delete(Object entity);
public boolean delete(Class entityClass);
public boolean delete(Class entityClass, String where, Object... params);

public boolean select(Object entity);
public boolean select(Rows rows);

这几个方法在上面的例子中都使用到了，
所有方法都返回boolean类型，当然也可以像JDBC API中那样返回一个数字，
目前对返回值的设计方案还需要进一步权衡，返回boolean类型实现起来比较简单，
当开发人员用if语句判断执行结果时最多不超过两个分支就知道方法的执行情况了，
如果返回一个数字至少需要三次判断(出错、没有行受影响、有多行受影响)，
涉及到批量更新时返回值也更加复杂，而且不同的数据库驱动可能在实现上稍有不同，
实际情况中也很少向最终用户提供那么详细的信息，
比如当用户通过你开发的界面删除或更新完某些记录后，
你只是简单的提供一条:"XXX表单中的记录已删除成功"这样的信息。
经过这样的考量后，也为了简化起见，目前暂时使用返回boolean类型的方案。

insert(Object entity);
update(Object entity);
delete(Object entity);
select(Object entity);

这四个方法是用来插入、更新、删除、查找单条记录的，
参数entity表示一个实体，通常是一个模型类的实例。

上例中的for语句就是用"c.insert(pet);"来插入5条宠物记录:

		for(int i=1; i<=5; i++) {
			Pet pet = new Pet();
			pet.name("pet"+i);
			pet.age(i);
			c.insert(pet);

			if(i == 3) middle = pet.id(); //id值自动获取
			out.println("insert pet: id = "+pet.id()+" name = "+pet.name()+" age = "+pet.age());
		}

上面代码中还有一点是值得一提的:
因为pet表的id列是自动增加的(auto_increment)，
所以你不并显示的调用pet.id(XXX)来给id赋值，
Douyu足够聪明，她运用了JDBC3.0规范中引入的"Retrieving Auto Generated Keys"功能来
自动获取数据库生成的id值，
这时就可以通过pet.id()来引用了，
如上面的代码:"if(i == 3) middle = pet.id();"就是把每三条记录的id值保存到middle变量中。

接下来，为了演示select(Object entity)的用法，先生成一个新的Pet对像，
把这个Pet对像的id值设为middle，
调用select(Object entity)就把其他两个值:name与age都查出来了。

Pet pet = new Pet();
pet.id(middle);
c.select(pet);

然后，更新pet的name值为"MyPet"，接着删除pet，如下:

pet.name("MyPet");
c.update(pet);
....
c.delete(pet);

update方法还有另一个重载形式:

public boolean update(Object entity, String where, Object... params);

这个方法是采用where子句的方式来更新记录的，
但是重载方法的第一个参数entity与update(Object entity)中的entity存在语义上的差别，
update(Object entity)中的entity对应的模型类是按照主键来更新的，
像这样:

UPDATE pet SET name=?,age=? WHERE id=?

占位符(?号)的取值都从entity中取，

而重载形式的entity，是按where与params参数生成where语句来更新的，
像这样:

UPDATE pet SET age=? WHERE age<3

where语句前半段的占位符(?号)的取值从entity取，
而后半段的占位符(?号)的取值从params取(如是String where中没有占位符，params是可选的)

比如上面的代码中的:

		out.println("把小于3岁的宠物的年龄都改成3岁");
		pet = new Pet();
		pet.age(3);
		c.update(pet,"age<3"); //与c.update(pet,"age<?",3)相同

就会在运行时生成:UPDATE pet SET age=? WHERE age<3
其中"SET age=?"就对应 pet.age(3) ，而"WHERE age<3"就是由 c.update(pet,"age<3") 生成的。


delete方法有两种重载形式:

public boolean delete(Class entityClass);
public boolean delete(Class entityClass, String where, Object... params);

第一个重载形式delete(Class entityClass)是用来删除所有记录的(使用这个方法时要特别小心).

与update方法的重载形式不同，因为删除操作只需要where子句就够了，
所以第一个参数是Class entityClass，而不是Object entity，其他都与update方法相同。

上例中也用到了这两个方法:

		out.println("删除年龄为5岁的宠物");
		c.delete(Pet.class, "age=5"); //与c.delete(Pet.class, "age=?", 5)相同
		......
		out.println("删除所有宠物");
		c.delete(Pet.class);

select方法也有另一个重载形式:

public boolean select(Rows rows);

参数rows是com.douyu.sql.Rows类型，可以把Rows类想像成一个容器，用来存放查询结果，
它还可以充当一个查询条件指示器。
Rows类定义了很多public变量，开发人员可以根据需要改变public变量的值，
然后通过select(Rows rows)方法传送到运行时上下文环境中，
Douyu就会按照查询条件查找记录。

Rows类定义的public变量包括上例中出现的offset、limit、orderBy，
还有distinct、groupBy、having、where、join等等，
这些都与标准的SQL SELECT语法一样，不过offset、limit是数据库特有的，
在Douyu目前的实现中对MySQL和Oracle做了优化，分页查询都是用本地查询方式，
比如上例中的:

		out.println("查找前2条宠物");
		rows.clear();
		rows.offset = 1;
		rows.limit = 2;
		rows.orderBy = "name";
		c.select(rows);

你会在运行服务器的控制台窗口中看到如下的SQL语句:

SELECT * FROM pet ORDER BY name LIMIT ?,?

这就是MySQL特有的分页查询语法。


最后，com.douyu.sql.Rows类还支持多表查询，
使用也很简单，只需这样:

Rows rows = new Rows(TableA.class,TableB.class);

具体用法请看下节: 表间的关联关系。

2.9.3 表间的关联关系


Douyu实现ORM自动化的基石是: 数据库的元数据
(例如调用java.sql.DatabaseMetaData接口中的各类方法获得的元数据及java.sql包中提供的其他信息)

表与表之间是否存在关联的依据是:
如果表B存在外部键(foreign key)，且表B的外部键引用了表A的主键(primary key)，
那么我们就说表A和表B存在关联。
可以把表A称为主表，把表B称为从表。表A和表B可以是同一个表(自引用)。
表间的关联关系可以简称为:主-从关系。

主-从关系并没有明确说明下面的问题:
主表的一条记录是对应从表的一条记录吗？(1:1)
主表的一条记录是对应从表的多条记录吗？(1:多)
主表的多条记录是对应从表的多条记录吗？(多:多)


为什么Oracle、DB2等等这些老牌的数据库厂商不在他们的数据库中通过扩展SQL语法来
解决这些问题呢，不是技术实力不够，而是没有必要，
你要实现(1:1)，只要在从表中多加个唯一约束就行了，(多:多)也可以拆分成两个(1:多)。
(1:1)、(1:多)、(多:多)只适合于从概念上描述具体的业务逻辑，
只是为了交流方便而形成的词汇，一听到这三个词别人就知道你在说什么。

既然在关系数据库的SQL语法中没有用专用的语法表示它们，
在应用层也没有必要用独特的语法来表示它们。
(比如你可能很熟悉的has_one, has_many, many_to_many......)
说得绝对一点，在应用层出现has_one, has_many这类声明从一开始就是错误的，
如果在一个框架或开发平台中包涵了很多概念(或名词)，
你就得先学习这些概念是什么意思，增加了学习难度。
要了解的概念越多，也就意味着这个框架或开发平台变得越来越复杂。

学习Douyu的ORM，你不必关心什么是(1:1)、(1:多)、(多:多)，Douyu也无视这些概念，
Douyu的ORM忠实于关系数据库，在Douyu看来，
如果关系数据库中两个表存在主-从关系，对应到Java语言，也就是两个模型类存在引用关系。


2.9.4 将主-从关系映射到模型类


2.9.4.1 主-从表

老师和学生存在主-从关系，
在MySQL中可以通过下面的表来定义这样的主-从关系:

drop table if exists student;
drop table if exists teacher;

create table teacher(
id  int not null auto_increment,
name varchar(10) not null,
primary key(id)
);
create table student(
id  int not null auto_increment,
name varchar(10) not null,
teacher_id  int not null,
birthday date,
foreign key(teacher_id) references teacher(id) on delete cascade,
primary key(id)
);

teacher_id是student表中的外部键，它引用了teacher表的主键id，
这样就建立了老师和学生的主-从关系，
还有一些小细节，teacher_id的取名并没有限制(比如你可以改为t_id)，
"on delete cascade"表示删除teacher表的记录时删除student表中相应的记录。

Douyu鼓励你使用"on delete cascade"这样的完整性约束，
这样你在应用层删除主表或修改主表的记录时，从表也会自动跟着改变，
完整性约束是数据库的强项，你在应用层中没必要自己维护完整性约束，
除非你能确保你的应用程序独占一个数据库，否则要是多个应用程序使用同一数据库时，
别的应用程序也要自己维护完整性约束，这不但增加了重复劳动，还可能会出错。

最后请对照上节的方法，把上面的SQL建表脚本copy到MySQL monitor中运行，
然后重新启动Douyu服务器。

Douyu目前没有找到最佳的办法来监听数据库内部的变化细节，
比如添加了字段或添加了新的表，JDBC规范没有定义任何相关的功能，
不过在最新的Oracle11g所带的驱动中加入了数据库改变通知特性(Database Change Notification)，
这对实现缓存模型比较有用，但是还有很多数据库驱动并不支持这样的特性，
所以要依赖数据库驱动来向应用层提供数据库的变更信息目前来讲还不太现实。

应用层要想做到通用，还得主动去获取信息，比如开一个线程隔一断时间解析一下数据库元数据，
或者编译器在解析Java源文件时，如果找不到模型类(比如在启动服务器后才加入的表，就是现在的情况)
也解析一下数据库元数据，如果模型类已存在，但是对应的表修改或增加了新的列，
这时也得重新解析一下数据库元数据，解析完后，还必须重新检查其他引用到这个模型类的所有代码，
这样就会造成一连串的问题，其中性能问题是最严重的。

所以目前最好的办法还是重启Douyu服务器，毕竟重启一次也顶多几秒钟。


2.9.4.2 程序代码

//对应apps\sql\Relation.java文件

package sql;

import java.sql.Date;
import java.util.List;

import com.douyu.main.Context;
import com.douyu.main.Controller;

import com.douyu.sql.Rows;

import sql.table.mysql.Teacher;
import sql.table.mysql.Student;

@Controller
public class Relation {
	@SuppressWarnings("unchecked")
	public void index(Context c, java.io.PrintWriter out) {
		Teacher t = new Teacher();
		t.name("TeacherA");

		Student s =null;
		//增加5个学生
		for(int i=1; i<=5; i++) {
			s = new Student();
			s.name("Student"+i);
			s.birthday(Date.valueOf("1988-11-0"+i));
			t.addStudent(s);
		}
		c.insert(t); //只需调用一次insert方法，就可以把学生的记录也插入数据库

		t = new Teacher();
		t.name("TeacherB");

		//增加5个学生
		for(int i=11; i<=15; i++) {
			s = new Student();
			s.name("Student"+i);
			s.birthday(Date.valueOf("1988-11-"+i));
			t.addStudent(s);
		}
		c.insert(t);

		Rows rows = new Rows(Teacher.class, Student.class);
		rows.from = "teacher";
		rows.join = "student on teacher.id=student.teacher_id";
		c.select(rows);
		List<Teacher> teachers = (List<Teacher>)rows.rowList.get(0);
		List<Student> students = (List<Student>)rows.rowList.get(1);

		for(int i=0; i<rows.count; i++) {
			t = teachers.get(i);
			s = students.get(i);
			out.println("学生: "+s.name()+" 的生日是: "+s.birthday()
				+" 他的老师是: "+t.name());
		}
		c.delete(Teacher.class); //删除所有记录，包括student表中的所有记录
	}
}

2.9.4.3 运行 Relation

打开浏览器，输入 http://localhost:8000/sql.Relation
结果类似这样:





2.9.4.4 程序代码说明

上面的代码新出现了一个java.sql.Date,
因为表student有一列叫birthday，它在MySQL中的类型是date，按照JDBC规范的定义，
MySQL的date类型对应到Java语言的源代码时就是java.sql.Date,
这些类型映射的复杂细节开发人员可以不用去管的，由Douyu自动去处理。

在开发阶段可能还是会去查看模型类的Setter、Getter的参数或返回值类型，
这时你可以打开服务器配置文件conf\server.java，
然后把@Database项中的outputJavaSourceFiles属性设为true就可以了。


除了java.sql.Date外，上例中还多了
sql.table.mysql.Teacher与sql.table.mysql.Student，
这两个是Douyu自动生成的模型类，分别对应表teacher与student;
因为表teacher与student存在主-从关系，
所以模型类Teacher与模型类Student也把这样的主-从关系表示出来了，
采用的方法也很简单，模型类Teacher中有如下的代码:

	private List<Student> student_list = new ArrayList<Student>();
	public void addStudent(Student e) {
		e.setTeacher(this);
		student_list.add(e);
	}
	public List<Student> getStudentList() {
		return student_list;
	}
	public Student getStudent(int index) {
		return student_list.get(index);
	}
	public Student getStudent() {
		return student_list.get(0);
	}
	public void setStudent(Student e) {
		e.setTeacher(this);
		if(student_list.size() == 0) addStudent(e);
		else student_list.set(0,e);
	}

其核心就是一个List<Student> student_list，
这个List既可以放一条学生记录，也可以放多条学生记录(取决于你的实际需求)

模型类Student中有如下的代码:

	private Teacher teacher;
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}

每个Student实例都有一个Teacher teacher变量来指向它所属的Teacher实例。
这就是主-从关系映射到模型类的全部细节了(关于自引用的情形留到高级主题讨论吧)。


最后再来看看Rows类的新型用法:

		Rows rows = new Rows(Teacher.class, Student.class);
		rows.from = "teacher";
		rows.join = "student on teacher.id=student.teacher_id";
		c.select(rows);
		List<Teacher> teachers = (List<Teacher>)rows.rowList.get(0);
		List<Student> students = (List<Student>)rows.rowList.get(1);

		for(int i=0; i<rows.count; i++) {
			t = teachers.get(i);
			s = students.get(i);
			out.println("学生: "+s.name()+" 的生日是: "+s.birthday()
				+" 他的老师是: "+t.name());
		}

Rows类的构造函数是这样声明的:

public Rows(Class... tables)

你可以像Rows rows = new Rows(Teacher.class, Student.class)这样传入任意多个模型类，
只要不超过数据库的限制都没问题。
如果只有一个模型类，那么属于单表查询的情况，
推荐使用范型方式构造Rows对象，
如sql.Crud类中出现的"Rows<Pet> rows = new Rows<Pet>(Pet.class);"，
这样在遍历结果时不用再进行类型转换。

上例属于多表查询的情况，你可以加上@SuppressWarnings("unchecked")，
这样编译器不会发出强制性的警告，在遍历结果时也不用再进行类型转换了。

还有一点是需要注意的，单表查询时，rows.rowList的元素是表中的所有记录，
而多表查询时rows.rowList的元素个数取决于表的个数，
并且元素的顺序由调用Rows类的构造函数时的顺序确定，元素的类型都是List。

rows.count总是正确的，不管是单表或多表查询，你都可以用它来作为循环的结束条件，
但是rows.count并不总是数据库中的总行数(不等于count(*))，
它只是告诉你当前的查询结果返回了多少行。


关于主-从关系和Rows类很多地方都还有改进的空间，
有很多细节没有讲述，这篇方章只是入门性质的，更深的话题留到以后叙述了，
下一节介绍有关事务的话题。

2.9.4 事务


这里并不想介绍有关事务的基本概念，如果你还没有这方面的知识，
请查找与数据库有关的书籍，这类书通常都对事务的概念和性质进行了详细描述。

Douyu支持以下类型的事务:
单数据库单连接事务;
单数据库多连接事务;
多数据库多连接事务,或者你也可以叫它"分布式事务".

Douyu还支持保存点(Savepoint).

使用Douyu，你根本不需要了解上面这些概念，不管是单数据库还是多数据库，
你都可以使用com.douyu.main.Context接口中定义的下面三个方法来处理:

public void beginTransaction();
public void setSavepoint();
public void endTransaction();

Douyu内部使用一种堆栈式事务处理模型技术来实现事务的管理，
你可以使用像下面的样例代码那样处理各类事务:

context.beginTransaction();

context.insert(数据库A的模型类);
context.update(数据库B的模型类);
context.delete(数据库C的模型类);

context.setSavepoint();

context.insert(数据库A的模型类);
context.update(数据库B的模型类);
context.delete(数据库C的模型类);

context.setSavepoint();

..............

context.endTransaction();

上面的代码就像一个倒立的堆栈，
当你要开始一个事务时，调用context.beginTransaction();
context.beginTransaction()就像是栈底，
接着调用context中的insert、update、delete对不同数据库中的数据进行更新，
如果调用了context.setSavepoint()，
并且在setSavepoint()前所有的insert、update、delete操作都是成功的，
那么就相当于在堆栈中间插入了一块隔板，
然后可以继续调用insert、update、delete，如此循环下去，
如果先前的insert、update、delete只要有一个失败了，
那么后面的insert、update、delete、setSavepoint()实际上是没有执行的，
当最后调用context.endTransaction()时，说明已达到栈顶了，
通知Douyu去检查所有的操作记录，如果所有的操作都没出现异常，
那么提交所有的操作，如果存在异常，再寻找离栈顶最近的那块隔板(保存点)，
然后把栈顶到隔板之间的所有操作撤消，把隔板到栈底的所有操作都提交；
如果找不到任何一块隔板，那么撤消所有的操作。


使用Douyu来处理数据库有关的问题，
归纳起来，你只要掌握com.douyu.main.Context接口中的7个方法就够了:

context.insert;
context.update;
context.delete;
context.select;

context.beginTransaction;
context.setSavepoint;
context.endTransaction;

我想看到这里的读者已经发现一个问题了，
Douyu中的模型类是没有insert、update或beginTransaction等等这些方法的，
而是用Context来托管各种模型类
(你可能更喜欢"贫血模型"这个概念，不过我并不喜欢这类大词，因为我不适合当"咨询师")。


如果你熟悉Rails的话，在Rails的ActiveRecord中，每个模型类都得继承一个基类，
insert、update这类操作是直接基于模型类的，
唯一的好处是在进行查询操作时返回结果不需要再强制转换为模型类，
除此之外，我并没有看到这种设计方案有什么好处，不但使模型类变得膨胀了，
也给事务的管理带来很多麻烦。
把对模型类的操作提取出来然后托管给一个Context，这种方式对实现对象缓存也是很有用的，
不过在目前发布的Douyu版本中并不支持对象缓存。


下面举一个例子来演示Douyu是怎样管理事务的，
这个例子并没有实际意义，只作为一个参考。


例子当中使用到了三个数据库: 一个Oracle数据库实例+两个MySQL数据库实例


2.9.4.1 配置数据库

Oracle数据库采用的是Oracle9i版本，
对应的驱动一般在oracle\ora90\jdbc\lib目录中，
但是里面的classes12.jar文件是10年前的了，仅支持JDBC2.0规范，
所以为了测试"保存点"这样的功能，最好是使有Oracle10g或Oracle11g自带的驱动，
我也装了Oracle11g个人版了，但是跑起来很慢很慢(电脑只有512M内存)，
不过Oracle11g自带的驱动同时支持Oracle9i和Oracle10g，
也实现了JDBC4.0规范几乎所有的特性(不支持SQLXML)，
所以为了能正常运行下面的例子请将\product\11.1.0\db_1\jdbc\lib\目录
下的ojdbc6_g.jar文件copy到D:\Douyu\lib目录中。

接着请启动Oracle数据库服务器，
然后用system用户以sysdba身份进入SQL Plus，
先用下面的命令建个douyu用户,密码也是douyu，接着给douyu授权，
并切换到douyu用户：
=============================================================
create user douyu identified by douyu
default tablespace users
temporary tablespace temp;

grant connect,resource to douyu;
conn douyu/douyu;

=============================================================

运行结果如下:
=============================================================
SQL> create user douyu identified by douyu
  2  default tablespace users
  3  temporary tablespace temp;

User created.

SQL> grant connect,resource to douyu;

Grant succeeded.

SQL> conn douyu/douyu;
Connected.
=============================================================

最后再建一张表:
=============================================================
create table table1(
  f1 varchar2(4) not null
);
=============================================================

运行结果如下:
=============================================================
SQL> create table table1(
  2    f1 varchar2(4) not null
  3  );

Table created.
=============================================================

table1很简单，只有一个长度为4的可变字符串字段f1，
为了测试目的，故意把长度设成4，这个长度很小，当字符串超个4个字符是就会引起异常。

到这里，Oracle的数据库配置就完成了，
接下来再对MySQL进行配置。

如果你是按顺序读下来的，并且还一边动手实验了，
那么在你的MySQL中已有一个叫douyu的数据库了，
注意，Oracle是以用户名来区分不同的"数据库"的，
而MySQL是通过调用create database语句来创建数据库。

还是先启动MySQL monitor，然后在先前的douyu数据库建一个表:
=============================================================
drop table if exists table2;

create table table2(
  id  int not null auto_increment,
  f2 varchar(4) not null,
  primary key(id)
);
=============================================================
运行结果如下:
=============================================================
mysql> use douyu;
Database changed
mysql> drop table if exists table2;
Query OK, 0 rows affected, 1 warning (0.02 sec)

mysql>
mysql> create table table2(
    ->   id  int not null auto_increment,
    ->   f2 varchar(4) not null,
    ->   primary key(id)
    -> );
Query OK, 0 rows affected (0.23 sec)

=============================================================

接着在MySQL中再建一个名叫douyu3的数据库，然后再建一个表:
=============================================================
drop table if exists table3;

create table table3(
  id  int not null auto_increment,
  f3 varchar(4) not null,
  primary key(id)
);
=============================================================

运行结果如下:
=============================================================
mysql> create database douyu3;
Query OK, 1 row affected (0.06 sec)

mysql> use douyu3;
Database changed
mysql> drop table if exists table3;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql>
mysql> create table table3(
    ->   id  int not null auto_increment,
    ->   f3 varchar(4) not null,
    ->   primary key(id)
    -> );
Query OK, 0 rows affected (0.16 sec)

=============================================================

至此，与数据库自身相关的配置工作全部结束了。


2.9.4.2 修改Douyu服务器的配置文件

如果Douyu服务器正在运行，请先连按两次 Ctrl+C 键停止服务器，
然后打开conf\server.java文件，
然后像下面这样增加两个数据库配置项:

	databases = {
		@Database (
			printSQL = true,
			//outputJavaSourceFiles = true,
			dialect = SQLDialect.Oracle9i,
			name="oracle",
			packageName="sql.table.oracle",

			//Oracle的java.sql.Driver接口实现类
			driver="oracle.jdbc.OracleDriver",
			//Oracle特有的url语法，
			//其中的MyOracle是在Oracle中的数据库名实例名，请根据你的实际情况修改
			url="jdbc:oracle:thin:@127.0.0.1:1521:MyOracle",
			userName="douyu",
			password="douyu",
			tableNames="*"
		),
		@Database (
			printSQL = true,
			//outputJavaSourceFiles = true,
			dialect = SQLDialect.MySQL,
			name="mysql3",
			packageName="sql.table.mysql3",
			driver="com.mysql.jdbc.Driver",
			url="jdbc:mysql://localhost/douyu3",
			userName="请把你的用户名放在这里",
			password="请把你的密码放在这里",
			tableNames="*"
		),
		//以下列出的只是常用选项，还有很多选项未在此处列出
		@Database (
			//是否在控制台打印运行期间生成的SQL语句(主要用于调试目的)
			printSQL = true,

			//是否输出模型类的源文件(主要用于开发参考目的，你没必要修成输出文件的内容)
			//outputJavaSourceFiles = true,

			//数据库方言
			dialect = SQLDialect.MySQL,

			//在Java源代码层使用的数据库名称，
			//如果同时配置了多个数据库，数据库名称不能相同
			name="mysql",

			//模型类所属包名，
			//包名是可以任取的，但建议不要跟你其他代码中的包名一样，
			//你可以通过import sql.table.mysql.*;这样的语句引用自动生成的模型类
			packageName="sql.table.mysql",

			//MySQL的java.sql.Driver接口实现类
			driver="com.mysql.jdbc.Driver",

			//MySQL特有的url语法，
			//其中的douyu是在MySQL中定义的数据库名，请根据你的实际情况修改
			url="jdbc:mysql://localhost/douyu",
			//用户名(通常是root)
			userName="请把你的用户名放在这里",
			//密码
			password="请把你的密码放在这里",
			
			//用tableNames参数告诉Douyu自动解析哪些表，
			//表名用逗号分隔，不区分大小写，如果是"*"号，那么自动解析所有表。
			tableNames="*"
		)
	},

修改完后请先保存，然后重新启动Douyu服务器。
结果如下图:





2.9.4.3 程序代码

//对应apps\sql\Relation.java文件

package sql;

import com.douyu.main.Context;
import com.douyu.main.Controller;

import com.douyu.sql.Rows;

import sql.table.oracle.Table1;
import sql.table.mysql.Table2;
import sql.table.mysql3.Table3;

@Controller
public class Transaction {
	public void index(Context c, java.io.PrintWriter out) {
		Table1 t1 = new Table1();
		t1.f1("1234");
		Table2 t2 = new Table2();
		t2.f2("1234");
		Table3 t3 = new Table3();
		t3.f3("1234");

		c.beginTransaction();

		c.insert(t1);
		c.insert(t2);
		c.insert(t3);

		//设一个保存点，
		//前面三条inser语句会成功，
		//因为字符串"1234"的长度不超过4，
		c.setSavepoint(); 

		t2.f2("abcd");
		c.update(t2);
		
		//再设一个保存点，
		//因为字符串"abcd"的长度也不超过4，确保是成功的。
		c.setSavepoint();

		t3.f3("abcd");
		t2.f2("12345");
		c.update(t3);
		c.update(t2);
		
		//字符串"12345"的长度超过4了，所以c.update(t2)会出现错误，
		//从而导致c.update(t3)的操作是无效的
		c.endTransaction();
		
		//查看出现了什么错误:
		out.println("contextException = "+c.getContextException());


		Rows<Table1> rows1 = new Rows<Table1>(Table1.class);
		c.select(rows1);
		for(Table1 table1 : rows1.rowList) {
			out.println("table1.f1 = "+table1.f1());
		}

		Rows<Table2> rows2 = new Rows<Table2>(Table2.class);
		c.select(rows2);
		for(Table2 table2 : rows2.rowList) {
			out.println("table2.f2 = "+table2.f2());
		}

		Rows<Table3> rows3 = new Rows<Table3>(Table3.class);
		c.select(rows3);
		for(Table3 table3 : rows3.rowList) {
			out.println("table3.f3 = "+table3.f3());
		}

		c.delete(Table1.class);
		c.delete(Table2.class);
		c.delete(Table3.class);
	}
}

2.9.4.4 运行 Transaction

打开浏览器，输入 http://localhost:8000/sql.Transaction
结果类似这样:

contextException = com.douyu.main.ContextException: com.mysql.jdbc.MysqlDataTruncation: Data truncation: Data too long for column 'f2' at row 1
table1.f1 = 1234
table2.f2 = abcd
table3.f3 = 1234

2.9.4.5 程序代码说明


代码不复杂，请参考代码中的注释就可以了。