随笔:93 文章:11 评论:22 引用:0
首页 发新随笔
发新文章 联系 聚合管理

2011年8月25日

--查询表空间、表空间大小及表空间对应物理路径

select a.tablespace_name,b.file_name,a.block_size,a.block_size,b.bytes/1024

/1024 "Sum MB" from dba_tablespaces a,dba_data_files b where a.tablespace_name=b.tablespace_name;

--查询表空间使用情况

  SELECT UPPER(F.TABLESPACE_NAME) "表空间名",

  D.TOT_GROOTTE_MB "表空间大小(M)",

  D.TOT_GROOTTE_MB - F.TOTAL_BYTES "已使用空间(M)",

  TO_CHAR(ROUND((D.TOT_GROOTTE_MB - F.TOTAL_BYTES) / D.TOT_GROOTTE_MB * 100,2),'990.99') || '%' "使用比",

  F.TOTAL_BYTES "空闲空间(M)",

  F.MAX_BYTES "最大块(M)"

  FROM (SELECT TABLESPACE_NAME,

  ROUND(SUM(BYTES) / (1024 * 1024), 2) TOTAL_BYTES,

  ROUND(MAX(BYTES) / (1024 * 1024), 2) MAX_BYTES

  FROM SYS.DBA_FREE_SPACE

  GROUP BY TABLESPACE_NAME) F,

  (SELECT DD.TABLESPACE_NAME,

   ROUND(SUM(DD.BYTES) / (1024 * 1024), 2) TOT_GROOTTE_MB

  FROM SYS.DBA_DATA_FILES DD

  GROUP BY DD.TABLESPACE_NAME) D

  WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME

  ORDER BY 1;

--查询表空间的free space

  select tablespace_name,

  count(*) as extends,

  round(sum(bytes) / 1024 / 1024, 2) as MB,

  sum(blocks) as blocks

  from dba_free_space

group by tablespace_name;

 

--查询表空间的总容量

  select tablespace_name, sum(bytes) / 1024 / 1024 as MB

  from dba_data_files

  group by tablespace_name;

 

 

--查询表空间使用率

  select total.tablespace_name,

  round(total.MB, 2) as Total_MB,考试大论坛

  round(total.MB - free.MB, 2) as Used_MB,

  round((1 - free.MB / total.MB) * 100, 2) || '%' as Used_Pct

  from (select tablespace_name, sum(bytes) / 1024 / 1024 as MB

  from dba_free_space

  group by tablespace_name) free,

  (select tablespace_name, sum(bytes) / 1024 / 1024 as MB

  from dba_data_files

  group by tablespace_name) total

  where free.tablespace_name = total.tablespace_name;

 

 

1.查找当前表级锁的SQL如下:

select sess.sid,

    sess.serial#,

    lo.oracle_username,

    lo.os_user_name,

    ao.object_name,

    lo.locked_mode

    from v$locked_object lo,

    dba_objects ao,

    v$session sess

where ao.object_id = lo.object_id and lo.session_id = sess.sid;

 

2.杀掉锁表进程:

alter system kill session '436,35123';

 

3.RAC环境中锁查找:

SELECT inst_id,DECODE(request,0,'Holder: ','Waiter: ')||sid sess,

        id1, id2, lmode, request, type,block,ctime

FROM GV$LOCK

WHERE (id1, id2, type) IN

       (SELECT id1, id2, type FROM GV$LOCK WHERE request>0)

ORDER BY id1, request;

  

 

 

4.监控当前数据库谁在运行什么SQL语句

select osuser, username, sql_text 

from  v$session a, v$sqltext b

where  a.sql_address =b.address order by address, piece;

 

 

 

5.找使用CPU多的用户session

select a.sid,spid,status,substr(a.program,1,40) prog, a.terminal,osuser,value/60/100 value

from  v$session a,v$process b,v$sesstat c

where  c.statistic#=12 and 

       c.sid=a.sid and 

       a.paddr=b.addr 

       order by value desc;

 

 

6.查看死锁信息

SELECT (SELECT username

          FROM v$session

         WHERE SID = a.SID) blocker, a.SID, 'is blocking',

       (SELECT username

          FROM v$session

         WHERE SID = b.SID) blockee, b.SID

  FROM v$lock a, v$lock b

 WHERE a.BLOCK = 1 AND b.request > 0 AND a.id1 = b.id1 AND a.id2 = b.id2;

 

 

7.具有最高等待的对象

SELECT   o.OWNER,o.object_name, o.object_type, a.event,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, dba_objects o

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.current_obj# = o.object_id

GROUP BY o.OWNER,o.object_name, o.object_type, a.event

ORDER BY total_wait_time DESC;

 

 

SELECT   a.session_id, s.osuser, s.machine, s.program, o.owner, o.object_name,

         o.object_type, a.event,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, dba_objects o, v$session s

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.current_obj# = o.object_id

     AND a.session_id = s.SID

GROUP BY o.owner,

         o.object_name,

         o.object_type,

         a.event,

         a.session_id,

         s.program,

         s.machine,

         s.osuser

ORDER BY total_wait_time DESC;

 

 

 

8.查询当前连接会话数

select s.value,s.sid,a.username

from

v$sesstat S,v$statname N,v$session A

where

n.statistic#=s.statistic# and

name='session pga memory'

and s.sid=a.sid

order by s.value;

 

 

 

9.等待最多的用户

SELECT   s.SID, s.username, SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, v$session s

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

GROUP BY s.SID, s.username

ORDER BY total_wait_time DESC;

 

 

 

10.等待最多的SQL

SELECT   a.program, a.session_id, a.user_id, d.username, s.sql_text,

         SUM (a.wait_time + a.time_waited) total_wait_time

    FROM v$active_session_history a, v$sqlarea s, dba_users d

   WHERE a.sample_time BETWEEN SYSDATE - 30 / 2880 AND SYSDATE

     AND a.sql_id = s.sql_id

     AND a.user_id = d.user_id

GROUP BY a.program, a.session_id, a.user_id, s.sql_text, d.username;

 

 

 

11.查看消耗资源最多的SQL

SELECT hash_value, executions, buffer_gets, disk_reads, parse_calls

FROM V$SQLAREA

WHERE buffer_gets > 10000000 OR disk_reads > 1000000

ORDER BY buffer_gets + 100 * disk_reads DESC;

 

 

 

12.查看某条SQL语句的资源消耗

SELECT hash_value, buffer_gets, disk_reads, executions, parse_calls

FROM V$SQLAREA

WHERE hash_Value = 228801498 AND address = hextoraw('CBD8E4B0');

 

 

13.查询会话执行的实际SQL

SELECT   a.SID, a.username, s.sql_text

    FROM v$session a, v$sqltext s

   WHERE a.sql_address = s.address

     AND a.sql_hash_value = s.hash_value

     AND a.status = 'ACTIVE'

ORDER BY a.username, a.SID, s.piece;

 

 

14.显示正在等待锁的所有会话

SELECT * FROM DBA_WAITERS;

 

DDL

--------------------------------------------------------------

/*注意点:

 

1.如果在PL/SQL 等工具里打开的话,直接修改下面的代码中[斜体加粗部分]执行

 

2.确保路径存在,比如【D:\oracle\oradata\Oracle9i\】也就是你要保存文件的路径存在

 

/*分为四步 */

 

/*第1步:创建临时表空间  */

 

create temporary tablespace user_temp 

 

tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf'

 

size 50m 

 

autoextend on 

 

next 50m maxsize 20480m 

 

extent management local; 

 

 

 

/*第2步:创建数据表空间  */

 

create tablespace user_data 

 

logging 

 

datafile 'D:\oracle\oradata\Oracle9i\user_data.dbf'

 

size 50m 

 

autoextend on 

 

next 50m maxsize 20480m 

 

extent management local; 

 

 

 

/*第3步:创建用户并指定表空间  */

 

create user username identified by password 

 

default tablespace user_data 

 

temporary tablespace user_temp; 

 

 

 

/*第4步:给用户授予权限  */

 

grant connect,resource,dba to username; 

posted @ 2014-03-03 15:48 redcoatjk 阅读(334) | 评论 (0)编辑 收藏
 
摘自: http://www.douban.com/note/235086917/
http://jackleechina.iteye.com/blog/1595397

为什么一般要采用事件监听而不是直接对元素的事件属性(如:onclick、onmouseover)赋值?

原来用事件属性只能赋值一种方法,即:

button1.onclick = function() { alert(1); };
button1.onclick = function() { alert(2); };

这样后面的赋值语句就将前面的onclick属性覆盖了

而使用添加事件监听的方式就可以实现并行。特别是当团队合作时,事件并行的需求增多,比如:监听document对象的鼠标事件或者window对象的载入事件等。使用事件属性则很容易造成事件覆盖掉

使用事件监听有两种方式:attachEvent和addEventListener

attachEvent与addEventListener区别
适应的浏览器版本不同,同时在使用的过程中要注意
attachEvent方法 按钮onclick
addEventListener方法 按钮click
attachEvent方法, (ie系列)
addEventListener方法 Mozilla系列

例子如下:
 1<!DOCTYPE html>
 2<html>
 3
 4<SCRIPT LANGUAGE="JavaScript">
 5function method1(){
 6    alert("method1");
 7}

 8function method2(){
 9    alert("method2");
10}

11function method3(){
12    alert("method3");
13}

14
</SCRIPT>
15<body>
16<input type="button"  value="dom 元素事件属性绑定的按钮" id="button1"/>
17<input type="button"  value="IE浏览器: attachEvent进行事件绑定的按钮" id="btn1"/>
18<input type="button"  value="火狐浏览器: addEventListener进行事件绑定的按钮" id="btn2"/>
19
20<SCRIPT LANGUAGE="JavaScript">
21     /**方法一: 使用元素的事件属性. [这种方式事件只可绑定一次,最后绑定的执行]**/
22     button1.onclick = function() { alert("1-1"); };
23     button1.onclick = function() { alert("1-2"); };
24     /**方法二: 使用attachEvent注册事件. 格式如下object.attachEvent(event,function);**/
25   var btn1Obj = document.getElementById("btn1");
26    btn1Obj.attachEvent("onclick", method1);
27   btn1Obj.attachEvent("onclick", method2);
28    btn1Obj.attachEvent("onclick", method3);
29     /**方法三: addEventListener. 格式如下element.addEventListener(type,listener,useCapture);**/
30    var btn2Obj = document.getElementById("btn2");
31    btn2Obj.addEventListener("click",method1,false);
32    btn2Obj.addEventListener("click",method2,false);
33    btn2Obj.addEventListener("click",method3,false);
34    //执行顺序为method1->method2->method3
35
</SCRIPT>
36<br/>attachEvent按照注册倒叙执行:    执行顺序为method3->method2->method1 
37<br/>addEventListener按照注册顺序执行:    执行顺序为method1->method2->method3 
38</body>
39</html>

相关衍生阅读:

JavaScript欲速则不达——基本处理事件详解和阻止事件传播

posted @ 2013-11-04 14:22 redcoatjk 阅读(424) | 评论 (0)编辑 收藏
 
     摘要: 摘自http://zhangjunhd.blog.51cto.com/113473/20629/ 1.Servlet过滤器 1.1 什么是过滤器 过滤器是一个程序,它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上,并且可以检查进入这些资源的请求信息。在这之后,过滤器可以作如下的选择: ①以常规的方式调用资源(即,调...  阅读全文
posted @ 2013-04-16 17:28 redcoatjk 阅读(252) | 评论 (0)编辑 收藏
 
     摘要: 摘自 http://www.sandzhang.com/blog/2010/04/07/mysql-show-status-explained-detail/ 要查看MySQL运行状态,要优化MySQL运行效率都少不了要运行show status查看各种状态,下面是参考官方文档及网上资料整理出来的中文详细解释:  如有问题,欢迎指正 状态名 作用域 ...  阅读全文
posted @ 2012-09-05 15:33 redcoatjk 阅读(2096) | 评论 (1)编辑 收藏
 
     摘要: 代码中反复开关自动提交没有必要. 其他方面写得还是很不错的.清晰.摘自 http://wangqinqin.iteye.com/blog/547277  PreparedStatement: 1) addBatch()将一组参数添加到PreparedStatement对象内部。 2) executeBatch()将一批参数提交给数据库来执行,如果全部命令执行成功...  阅读全文
posted @ 2012-07-20 15:04 redcoatjk 阅读(18615) | 评论 (1)编辑 收藏
 
摘自 http://neoremind.net/2010/12/preparedstatement_diff/

JDBC中Statement与PreparedStatement的区别

1. statement每次执行sql语句,相关数据库都要执行sql语句的编译;preparedstatement是预编译的, 采用Cache机制(预编译语句,放在Cache中,下次执行相同SQL语句时,则可以直接从Cache中取出来,有利于sql生成查询计划。),对于批量处理可以大大提高效率. 也叫JDBC存储过程。

例如,如果要执行两条sql语句

SELECT colume FROM TABLE WHERE colume=1;
SELECT colume FROM TABLE WHERE colume=2;

会生成两个执行计划

一千个查询就生成一千个执行计划!

PreparedStatement用于使用绑定变量重用执行计划

SELECT colume FROM TABLE WHERE colume=:x;

通过set不同数据只需要生成一次执行计划,可以重用

是否使用绑定变量对系统影响非常大,生成执行计划极为消耗资源

两种实现 速度差距可能成百上千倍

后者使用了PreparedStatement对象,而前者是普通的Statement对象。PreparedStatement对象不仅包含了SQL语句,而且大多数情况下这个语句已经被预编译过,因而当其执行时,只需DBMS运行SQL语句,而不必先编译。当你需要执行Statement对象多次的时候,PreparedStatement对象将会大大降低运行时间,当然也加快了访问数据库的速度

这种转换也给你带来很大的便利,不必重复SQL语句的句法,而只需更改其中变量的值,便可重新执行SQL语句。选择PreparedStatement对象与否,在于相同句法的SQL语句是否执行了多次,而且两次之间的差别仅仅是变量的不同。如果仅仅执行了一次的话,在对数据库只执行一次性存取的时侯,用 Statement 对象进行处理,PreparedStatement 对象的开销比Statement大,对于一次性操作并不会带来额外的好处。

2. PrepareStatement中执行的SQL语句中是可以带参数的,也就是说可以替换变量,尽量采用使用?号的方式传递参数,增加代码的可读性又可以预编译加速;而Statement则不可以。

3. 防止SQL注入。在SQL中包含特殊字符或SQL的关键字(如:’ or 1 or ‘)时,Statement将出现不可预料的结果(出现异常或查询的结果不正确),可用PreparedStatement来解决。

SQL注入或者说SQL注入攻击就是利用Statement的漏洞完成的,例如用个用户登录,那么form表单有用户名和密码
那么我提交时,在用户名输入框内 输入 “aaa’ or ’a’=’a” 密码框随便输入,那么这样意味着 sql的
查询语言就是 “select * from 表 where 用户名=’aaa’ or ’a’=’a’ and 密码=’123’  ”,这样查询出来所有的数据或者是混乱。那么不被授权的用户照样可以登录,岂不是被黑了?!实际中现在java程序员早都不用这种方式写查询了,一般都用PreparedStatement来查询,或干脆就用hibernate之类的持久层框架,这样通过sql注入就无从谈起了。
posted @ 2012-07-20 11:14 redcoatjk 阅读(4405) | 评论 (2)编辑 收藏
 
摘自:http://ryxxlong.iteye.com/blog/552884

如何修改mysql root密码
  忘记MySQL ROOT密码是在MySQ使用中很常见的问题,可是有很多朋友并不会重置ROOT密码,那叫苦啊,特写此文章与大家交流:

1、编辑MySQL的配置文件:my.ini
一般在MySQL安装目录下有my.ini即MySQL的配置文件。
在此配置文件的最后添加如下一行:
skip-grant-tables
保存退出编辑。

2、然后重启MySQL服务
在命令行下执行:
net stop MySQL
net start MySQL

3、设置新的ROOT密码
然后用命令提示符cd到对应安装目录的bin下执行:
MySQL -u root -p MySQL或mysql -u root -p
直接回车无需密码即可进入数据库了。
此时,在命令行下执行 use mysql;
现在我们执行如下语句把root密码更新为:
update user set password=PASSWORD("root") where user='root';
(注意:此时不用使用mysqladmin -u root -p password '你的新密码'这条命令修改密码,因为'skip-grant-tables'配置,
不信的话,你可以试用一下,它肯定会报如下所示的错误:
F:\Documents and Settings\long>mysqladmin -u root -p password 'root'
Enter password:
Warning: single quotes were not trimmed from the password by your command
line client, as you might have expected.
mysqladmin:
You cannot use 'password' command as mysqld runs
 with grant tables disabled (was started with --skip-grant-tables).
Use: "mysqladmin flush-privileges password '*'" instead)
exit 退出MySQL。

4、还原配置文件并重启服务

然后修改MySQL配置文件把刚才添加的那一行'skip-grant-tables'删除。
再次重起MySQL服务,密码修改完毕。
用新密码root试一下吧,又能登入重新进入mysql了?



附mysql修改密码的一些方法:
1. 用MYSQL的grant语句,例如
mysql -h hostname –u root 命令登录到mysqld server 用grant 命令改变口令:
mysql -h 192.168.1.101 -u root
上边的192.168.1.101 是偶的mysqld 运行机器,你换成自己的,这样登录上去,就可以修改密码了,
其实没必要这么麻烦,直接mysql -u root就可以了。
GRANT ALL ON *.* TO 'root'@'localhost' IDENTIFIED BY 'root' WITH GRANT OPTION

2. mysqladmin -u 用户名 -p 旧密码 password 新密码
例1:给root 加个密码root。首先进入cmd中,然后键入
以下命令,至于在CMD下能否使用mysqladmin,
就要看你的Windows环境变量PATH中是否添加“E:\Program Files\MySQL\MySQL Server 5.1\bin;”(请改为你自己的安装路径)了。)
mysqladmin -u root password root
注:因为开始时root 没有密码,所以-p 旧密码一项就可以省略了。
例2:再将root 的密码改为admin。
mysqladmin –u root -proot password admin(注意-p 不要和后面的密码分
开写,要写在一起,不然会出错,错误如下所示:
F:\Documents and Settings\long>mysqladmin -u root -p root password admin
Enter password: ****
mysqladmin: Unknown command: 'root')
当然你也可以这样写:mysqladmin –u root -p password admin回车,
然后再输入你的旧密码,这样也是完全也可以的,看你的爱好了.
例3:再将root用户的密码去掉.
F:\Documents and Settings\long>mysqladmin -u root -p password  ;
Enter password: root
此时,root用户又没有密码了.可以通过下面的方法设置:
F:\Documents and Settings\long>mysql -u root
mysql>set password for 'root'@'localhost'=password('root');(语法:SET PASSWORD FOR '用户名'@'主机' = PASSWORD('密码'))
mysql>set password for 'root'@'%'=password('root');
//本条可选,这是在配置mysql数据库,如果你选择了允许root通过远程登录进来时,你在mysql数据库下的user表中,
use mysql;
select * from user;可以看到有两条记录,如果你没有配置这一项的话,只会第一条记录!
Host                    User     Password
'localhost', 'root', '*9C9F4927129ECC3209D8550DC8B67156FDBF9418', ...
'%', 'root', '*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B', ...
通过以上设置,root的密码将变为root这样就完成了根用户root密码的设置工作。

3. use mysql;
 update user set password =password('yourpass') where user='root'

(注:下面的这些方法我本人没有试过,不知对不对,我只是转载了一下:)
下面的方法都在mysql提示符下使用,且必须有mysql的root权限:
方法4
mysql> INSERT INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES
确切地说这是在增加一个用户,用户名为jeffrey,密码为biscuit。
在《mysql中文参考手册》里有这个例子,所以我也就写出来了。
注意要使用PASSWORD函数,然后还要使用FLUSH PRIVILEGES。

方法5
和方法三一样,只是使用了REPLACE语句
mysql> REPLACE INTO mysql.user (Host,User,Password)
VALUES('%','jeffrey',PASSWORD('biscuit'));
mysql> FLUSH PRIVILEGES

方法6
使用SET PASSWORD语句,
mysql> SET PASSWORD FOR jeffrey@"%" = PASSWORD('biscuit');
你也必须使用PASSWORD()函数,
但是不需要使用FLUSH PRIVILEGES。


方法7
使用GRANT ... IDENTIFIED BY语句
mysql> GRANT USAGE ON *.* TO jeffrey@"%" IDENTIFIED BY 'biscuit';
这里PASSWORD()函数是不必要的,也不需要使用FLUSH PRIVILEGES。

注:mysql 新设置用户或更改密码后需用flush privileges刷新MySQL的系统权限相关表,
否则会出现拒绝访问,还有一种方法,就是重新启动mysql服务器,来使新设置生效。

posted @ 2012-07-19 10:54 redcoatjk 阅读(314) | 评论 (0)编辑 收藏
 

怎么查看端口占用情况?

       开始--运行--cmd 进入命令提示符 输入netstat -ano 即可看到所有连接的PID 之后在任务管理器中找到这个PID所对应的程序如果任务管理器中没有PID这一项,可以在任务管理器中选"查看"-"选择列"

        经常,我们在启动应用的时候发现系统需要的端口被别的程序占用,如何知道谁占有了我们需要的端口,很多人都比较头疼,下面就介绍一种非常简单的方法,希望对大家有用

假如我们需要确定谁占用了我们的9050端口

1、Windows平台
在windows命令行窗口下执行:

C:\>netstat -aon|findstr "9050"

TCP 127.0.0.1:9050 0.0.0.0:0 LISTENING 2016


看到了吗,端口被进程号为2016的进程占用,继续执行下面命令:

C:\>tasklist|findstr "2016"

tor.exe 2016 Console 0 16,064 K

很清楚吧,tor占用了你的端口。

posted @ 2012-06-13 13:51 redcoatjk 阅读(247) | 评论 (0)编辑 收藏
 
JSON 即 JavaScript Object Natation,它是一种轻量级的数据交换格式,非常适合于服务器与 JavaScript 的交互。本文将快速讲解 JSON 格式,并通过代码示例演示如何分别在客户端和服务器端进行 JSON 格式数据的处理。
管有许多宣传关于 XML 如何拥有跨平台,跨语言的优势,然而,除非应用于 Web Services,否则,在普通的 Web 应用中,开发者经常为 XML 的解析伤透了脑筋,无论是服务器端生成或处理 XML,还是客户端用 JavaScript 解析 XML,都常常导致复杂的代码,极低的开发效率。实际上,对于大多数 Web 应用来说,他们根本不需要复杂的 XML 来传输数据,XML 的扩展性很少具有优势,许多 AJAX 应用甚至直接返回 HTML 片段来构建动态 Web 页面。和返回 XML 并解析它相比,返回 HTML 片段大大降低了系统的复杂性,但同时缺少了一定的灵活性。

现在, JSON 为 Web 应用开发者提供了另一种数据交换格式。让我们来看看 JSON 到底是什么,同 XML 或 HTML 片段相比,JSON 提供了更好的简单性和灵活性。

JSON 数据格式解析

和 XML 一样,JSON 也是基于纯文本的数据格式。由于 JSON 天生是为 JavaScript 准备的,因此,JSON 的数据格式非常简单,您可以用 JSON 传输一个简单的 String,Number,Boolean,也可以传输一个数组,或者一个复杂的 Object 对象。

String,Number 和 Boolean 用 JSON 表示非常简单。例如,用 JSON 表示一个简单的 String “ abc ”,其格式为:

"abc"

这与绝大多数编程语言的表示方法一致,例如:

12345(整数)
-3.9e10(浮点数)

Boolean 类型表示为 truefalse 。此外,JavaScript 中的 null 被表示为 null,注意,truefalsenull 都没有双引号,否则将被视为一个 String 。

JSON 还可以表示一个数组对象,使用 [] 包含所有元素,每个元素用逗号分隔,元素可以是任意的 Value,例如,以下数组包含了一个 String,Number,Boolean 和一个 null:

["abc",12345,false,null]

Object 对象在 JSON 中是用 {} 包含一系列无序的 Key-Value 键值对表示的,实际上此处的 Object 相当于 Java 中的 Map<String, Object>,而不是 Java 的 Class 。注意 Key 只能用 String 表示。

例如,一个 Address 对象包含如下 Key-Value:

city:Beijing 
street:Chaoyang Road
postcode:100025(整数)

用 JSON 表示如下:

{"city":"Beijing","street":" Chaoyang Road ","postcode":100025}

其中 Value 也可以是另一个 Object 或者数组,因此,复杂的 Object 可以嵌套表示,例如,一个 Person 对象包含 name 和 address 对象,可以表示如下:

{"name":"Michael","address":
{"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
}

JavaScript 处理 JSON 数据

上面介绍了如何用 JSON 表示数据,接下来,我们还要解决如何在服务器端生成 JSON 格式的数据以便发送到客户端,以及客户端如何使用 JavaScript 处理 JSON 格式的数据。

我们先讨论如何在 Web 页面中用 JavaScript 处理 JSON 数据。我们通过一个简单的 JavaScript 方法就能看到客户端如何将 JSON 数据表示给用户:

function handleJson() { 
var j={"name":"Michael","address":
{"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
};
document.write(j.name);
document.write(j.address.city);
}

假定服务器返回的 JSON 数据是上文的:

{"name":"Michael","address":
{"city":"Beijing","street":" Chaoyang Road ","postcode":100025}
}

只需将其赋值给一个 JavaScript 变量,就可以立刻使用该变量并更新页面中的信息了,相比 XML 需要从 DOM 中读取各种节点而言,JSON 的使用非常容易。我们需要做的仅仅是发送一个 Ajax 请求,然后将服务器返回的 JSON 数据赋值给一个变量即可。有许多 Ajax 框架早已包含了处理 JSON 数据的能力,例如 Prototype(一个流行的 JavaScript 库:http://prototypejs.org)提供了 evalJSON() 方法,能直接将服务器返回的 JSON 文本变成一个 JavaScript 变量:

new Ajax.Request("http://url", { 
method: "get",
onSuccess: function(transport) {
var json = transport.responseText.evalJSON();
// TODO: document.write(json.xxx);
}
});

服务器端输出 JSON 格式数据

下面我们讨论如何在服务器端输出 JSON 格式的数据。以 Java 为例,我们将演示将一个 Java 对象编码为 JSON 格式的文本。

将 String 对象编码为 JSON 格式时,只需处理好特殊字符即可。另外,必须用 (") 而非 (') 表示字符串:


static String string2Json(String s) {
StringBuilder sb = new StringBuilder(s.length()+20);
sb.append('\"');
for (int i=0; i<s.length(); i++) {
char c = s.charAt(i);
switch (c) {
case '\"':
sb.append("\\\"");
break;
case '\\':
sb.append("\\\\");
break;
case '/':
sb.append("\\/");
break;
case '\b':
sb.append("\\b");
break;
case '\f':
sb.append("\\f");
break;
case '\n':
sb.append("\\n");
break;
case '\r':
sb.append("\\r");
break;
case '\t':
sb.append("\\t");
break;
default:
sb.append(c);
}
}
sb.append('\"');
return sb.toString();
}

将 Number 表示为 JSON 就容易得多,利用 Java 的多态,我们可以处理 Integer,Long,Float 等多种 Number 格式:


static String number2Json(Number number) {
return number.toString();
}

Boolean 类型也可以直接通过 toString() 方法得到 JSON 的表示:


static String boolean2Json(Boolean bool) {
return bool.toString();
}

要将数组编码为 JSON 格式,可以通过循环将每一个元素编码出来:


static String array2Json(Object[] array) {
if (array.length==0)
return "[]";
StringBuilder sb = new StringBuilder(array.length << 4);
sb.append('[');
for (Object o : array) {
sb.append(toJson(o));
sb.append(',');
}
// 将最后添加的 ',' 变为 ']':
sb.setCharAt(sb.length()-1, ']');
return sb.toString();
}

最后,我们需要将 Map<String, Object> 编码为 JSON 格式,因为 JavaScript 的 Object 实际上对应的是 Java 的 Map<String, Object> 。该方法如下:


static String map2Json(Map<String, Object> map) {
if (map.isEmpty())
return "{}";
StringBuilder sb = new StringBuilder(map.size() << 4);
sb.append('{');
Set<String> keys = map.keySet();
for (String key : keys) {
Object value = map.get(key);
sb.append('\"');
sb.append(key);
sb.append('\"');
sb.append(':');
sb.append(toJson(value));
sb.append(',');
}
// 将最后的 ',' 变为 '}':
sb.setCharAt(sb.length()-1, '}');
return sb.toString();
}

为了统一处理任意的 Java 对象,我们编写一个入口方法 toJson(Object),能够将任意的 Java 对象编码为 JSON 格式:


public static String toJson(Object o) {
if (o==null)
return "null";
if (o instanceof String)
return string2Json((String)o);
if (o instanceof Boolean)
return boolean2Json((Boolean)o);
if (o instanceof Number)
return number2Json((Number)o);
if (o instanceof Map)
return map2Json((Map<String, Object>)o);
if (o instanceof Object[])
return array2Json((Object[])o);
throw new RuntimeException("Unsupported type: " + o.getClass().getName());
}

我们并未对 Java 对象作严格的检查。不被支持的对象(例如 List)将直接抛出 RuntimeException 。此外,为了保证输出的 JSON 是有效的,Map<String, Object> 对象的 Key 也不能包含特殊字符。细心的读者可能还会发现循环引用的对象会引发无限递归,例如,精心构造一个循环引用的 Map,就可以检测到 StackOverflowException


@Test(expected=StackOverflowError.class)
public void testRecurrsiveMap2Json() {
Map<String, Object> map = new HashMap<String, Object>();
map.put("key", map);
JsonUtil.map2Json(map);
}

好在服务器处理的 JSON 数据最终都应该转化为简单的 JavaScript 对象,因此,递归引用的可能性很小。

最后,通过 Servlet 或 MVC 框架输出 JSON 时,需要设置正确的 MIME 类型(application/json)和字符编码。假定服务器使用 UTF-8 编码,则可以使用以下代码输出编码后的 JSON 文本:


response.setContentType("application/json;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter pw = response.getWriter();
pw.write(JsonUtil.toJson(obj));
pw.flush();

小结

JSON 已经是 JavaScript 标准的一部分。目前,主流的浏览器对 JSON 支持都非常完善。应用 JSON,我们可以从 XML 的解析中摆脱出来,对那些应用 Ajax 的 Web 2.0 网站来说,JSON 确实是目前最灵活的轻量级方案。

posted @ 2012-02-27 11:00 redcoatjk 阅读(325) | 评论 (0)编辑 收藏
 
JNDI是 Java 命名与目录接口(Java Naming and Directory Interface),在J2EE规范中是重要的规范之一,不少专家认为,没有透彻理解JNDI的意义和作用,就没有真正掌握J2EE特别是EJB的知识。
那么,JNDI到底起什么作用?

要了解JNDI的作用,我们可以从“如果不用JNDI我们怎样做?用了JNDI后我们又将怎样做?”这个问题来探讨。

没有JNDI的做法:
程序员开发时,知道要开发访问MySQL数据库的应用,于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码,并通过使用适当的 JDBC URL 连接到数据库。
就像以下代码这样:

Connection conn=null;
try {Class.forName("com.mysql.jdbc.Driver",true, Thread.currentThread().getContextClassLoader());
conn=DriverManager.getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");
/* 使用conn并进行SQL操作 */......
conn.close();
}
catch(Exception e)
{e.printStackTrace();}
finally {if(conn!=null)
{try {conn.close();}
catch(SQLException e) {
}}}

这是传统的做法,也是以前非Java程序员(如Delphi、VB等)常见的做法。这种做法一般在小规模的开发过程中不会产生问题,只要程序员熟悉Java语言、了解JDBC技术和MySQL,可以很快开发出相应的应用程序。

没有JNDI的做法存在的问题:
1、数据库服务器名称MyDBServer 、用户名和口令都可能需要改变,由此引发JDBC URL需要修改;
2、数据库可能改用别的产品,如改用DB2或者Oracle,引发JDBC驱动程序包和类名需要修改;
3、随着实际使用终端的增加,原配置的连接池参数可能需要调整;
4、......

解决办法:
程序员应该不需要关心“具体的数据库后台是什么?JDBC驱动程序是什么?JDBC URL格式是什么?访问数据库的用户名和口令是什么?”等等这些问题,程序员编写的程序应该没有对 JDBC 驱动程序的引用,没有服务器名称,没有用户名称或口令 —— 甚至没有数据库池或连接管理。而是把这些问题交给J2EE容器来配置和管理,程序员只需要对这些配置和管理进行引用即可。

由此,就有了JNDI。

用了JNDI之后的做法:
首先,在在J2EE容器中配置JNDI参数,定义一个数据源,也就是JDBC引用参数,给这个数据源设置一个名称;然后,在程序中,通过数据源名称引用数据源从而访问后台数据库。
具体操作如下(以JBoss为例):
1、配置数据源
在JBoss的 D:\jboss420GA\docs\examples\jca 文件夹下面,有很多不同数据库引用的数据源定义模板。将其中的 mysql-ds.xml 文件Copy到你使用的服务器下,如 D:\jboss420GA\server\default\deploy。
修改 mysql-ds.xml 文件的内容,使之能通过JDBC正确访问你的MySQL数据库,如下:
<?xml version="1.0" encoding="UTF-8"?>
<datasources>
<local-tx-datasource>
    <jndi-name>MySqlDS</jndi-name>
    <connection-url>jdbc:mysql://localhost:3306/lw</connection-url>
    <driver-class>com.mysql.jdbc.Driver</driver-class>
    <user-name>root</user-name>
    <password>rootpassword</password>
<exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>
    <metadata>
       <type-mapping>mySQL</type-mapping>
    </metadata>
</local-tx-datasource>
</datasources>

这里,定义了一个名为MySqlDS的数据源,其参数包括JDBC的URL,驱动类名,用户名及密码等。

2、在程序中引用数据源:

Connection conn=null;
try
{
Context ctx=new InitialContext();
Object datasourceRef=ctx.lookup("java:MySqlDS");
//引用数据源
DataSource ds=(Datasource)datasourceRef;
conn=ds.getConnection();
/* 使用conn进行数据库SQL操作 */......
c.close();
}
catch(Exception e)
{e.printStackTrace();}
finally {if(conn!=null)
{
try
{
conn.close();
}
catch(SQLException e)
{
}}}
直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几,但是现在的程序可以不用关心具体JDBC参数了。
在系统部署后,如果数据库的相关参数变更,只需要重新配置 mysql-ds.xml 修改其中的JDBC参数,只要保证数据源的名称不变,那么程序源代码就无需修改。

由此可见,JNDI避免了程序与数据库之间的紧耦合,使应用更加易于配置、易于部署。

JNDI的扩展:
JNDI在满足了数据源配置的要求的基础上,还进一步扩充了作用:所有与系统外部的资源的引用,都可以通过JNDI定义和引用。

所以,在J2EE规范中,J2EE 中的资源并不局限于 JDBC 数据源。引用的类型有很多,其中包括资源引用(已经讨论过)、环境实体和 EJB 引用。特别是 EJB 引用,它暴露了 JNDI 在 J2EE 中的另外一项关键角色:查找其他应用程序组件。

EJB 的 JNDI 引用非常类似于 JDBC 资源的引用。在服务趋于转换的环境中,这是一种很有效的方法。可以对应用程序架构中所得到的所有组件进行这类配置管理,从 EJB 组件到 JMS 队列和主题,再到简单配置字符串或其他对象,这可以降低随时间的推移服务变更所产生的维护成本,同时还可以简化部署,减少集成工作。 外部资源”。


总结:
J2EE 规范要求所有 J2EE 容器都要提供 JNDI 规范的实现。JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在运行时间接地查找其他组件、资源或服务的通用机制。在多数情况下,提供 JNDI 供应者的容器可以充当有限的数据存储,这样管理员就可以设置应用程序的执行属性,并让其他应用程序引用这些属性(Java 管理扩展(Java Management Extensions,JMX)也可以用作这个目的)。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层,这样组件就可以发现所需要的资源,而不用了解这些间接性。

在 J2EE 中,JNDI 是把 J2EE 应用程序合在一起的粘合剂,JNDI 提供的间接寻址允许跨企业交付可伸缩的、功能强大且很灵活的应用程序。这是 J2EE 的承诺,而且经过一些计划和预先考虑,这个承诺是完全可以实现的。
posted @ 2012-02-14 10:24 redcoatjk 阅读(333) | 评论 (0)编辑 收藏
 

在Oracle中,要按特定条件查询前N条记录,用个rownum就搞定了。
select * from emp where rownum <= 5
结果只查询5条记录, oracle会自动展现一个rownum的属性表示记录排序号

而select * from emp where rownum > 5 ;则是失败的。
因为:rownum是oracle预处理字段,默认标序是1,只有记录集已经满足条件后才会进行后续编号。由于第一条记录rownum默认是1,而你的条件是rownum>=6 对第一条记录比较它的rownum肯定不大于6 所以不满足条件 oracle舍弃第一条记录将数据库第二条记录标序为1再进行比较  肯定都不满足rownum>=6  这样循环也就是说由于没有记录满足rownum>=6所以记录一直被舍弃,rownum一直是1 。

解决方案: 利用查询时,自动生成的rownum属性.
排序方法:
  select * from (
       select a1.*, rownum rwn  from emp a1   where rownum <=10
    ) where rwn >= 6;
  或者
  select * from (
    select qx.*,row_number() over(order by qx.empno) rwn from emp qx
  ) where rwn between 6 and 10
-------------------------------------------------------------------------
使用注意:

1排序导致数据重复:


table1中表有字段(其余字段省)
ID  主键
DATA_UPDATE_TIME 数据更新时间(只存储了年月日)

分页查询的语句如下
select *
   from (
        select row_.*, rownum rownum_
           from ( select  p.id from table1 p
             order by  p.DATA_UPDATE_TIME desc )
   row_ where rownum <= )
where rownum_ >

以每页显示10条为例
第一次  rownum <= 10)   where rownum_ > 0
第二次  rownum <= 20)   where rownum_ > 10

发现有一条记录在两次查询结果中重复出现,不知道问题出在哪里,请忙帮看看。

另:
DATA_UPDATE_TIME 的值有重复,不知道跟它有没有关系。
如果按ID排的话就不会出现这个问题


解答:
如果order by 不能唯一确定记录的顺序就会出现这个问题。
解决的方法是把分页部分全部拿到最外层进行。

Java代码 复制代码 收藏代码
  1. select * from (    
  2.   select row_.*, rownum rownum_    
  3.   from (   
  4.     select p.id from table1 p    
  5.     order by p.DATA_UPDATE_TIME desc    
  6.   ) row_   
  7. )    
  8. where rownum_ > ? and rownum_ <= ?   

2 排序的id顺序:
Oracle中的rownum的是在取数据的时候产生的序号,所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出,rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号,rowid也是顺序分配的。为了解决这个问题,必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
这样就成了按name排序,并且用rownum标出正确序号(有小到大)


------------
参考Oracle的rownum原理和使用  http://tenn.iteye.com/blog/99339

在Oracle中,要按特定条件查询前N条记录,用个rownum就搞定了。
select * from emp where rownum <= 5
而且书上也告诫,不能对rownum用">",这也就意味着,如果你想用
select * from emp where rownum > 5
则是失败的。要知道为什么会失败,则需要了解rownum背后的机制:
1 Oracle executes your query.

2 Oracle fetches the first row and calls it row number 1.

3 Have we gotten past row number meets the criteria? If no, then Oracle discards the row, If yes, then Oracle return the row.

4 Oracle fetches the next row and advances the row number (to 2, and then to 3, and then to 4, and so forth).

5 Go to step 3.

了解了原理,就知道rownum>不会成功,因为在第三步的时候查询出的行已经被丢弃,第四步查出来的rownum仍然是1,这样永远也不会成功。

同样道理,rownum如果单独用=,也只有在rownum=1时才有用。

 

对于rownum来说它是oracle系统顺序分配为从查询返回的行的编号,返回的第一行分配的是1,第二行是2,依此类推,这个伪字段可以用于限制查询返回的总行数,而且rownum不能以任何表的名称作为前缀。
 举例说明:
例如表:student(学生)表,表结构为:
ID       char(6)      --学号
name    VARCHAR2(10)   --姓名
create table student (ID char(6), name VARCHAR2(100));
insert into sale values('200001',‘张一’);
insert into sale values('200002',‘王二’);
insert into sale values('200003',‘李三’);
insert into sale values('200004',‘赵四’);
commit;
(1) rownum 对于等于某值的查询条件
如果希望找到学生表中第一条学生的信息,可以使用rownum=1作为条件。但是想找到学生表中第二条学生的信息,使用rownum=2结果查不到数据。因为rownum都是从1开始,但是1以上的自然数在rownum做等于判断是时认为都是false条件,所以无法查到rownum = n(n>1的自然数)。
SQL> select rownum,id,name from student where rownum=1;(可以用在限制返回记录条数的地方,保证不出错,如:隐式游标)
SQL> select rownum,id,name from student where rownum=1;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200001 张一
SQL> select rownum,id,name from student where rownum =2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
(2)rownum对于大于某值的查询条件
   如果想找到从第二行记录以后的记录,当使用rownum>2是查不出记录的,原因是由于rownum是一个总是从1开始的伪列,Oracle 认为rownum> n(n>1的自然数)这种条件依旧不成立,所以查不到记录
SQL> select rownum,id,name from student where rownum >2;
ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
那如何才能找到第二行以后的记录呀。可以使用以下的子查询方法来解决。注意子查询中的rownum必须要有别名,否则还是不会查出记录来,这是因为rownum不是某个表的列,如果不起别名的话,无法知道rownum是子查询的列还是主查询的列。
SQL>select * from(select rownum no ,id,name from student) where no>2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         4 200004 赵四
SQL> select * from(select rownum,id,name from student)where rownum>2;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
(3)rownum对于小于某值的查询条件
如果想找到第三条记录以前的记录,当使用rownum<3是能得到两条记录的。显然rownum对于rownum<n((n>1的自然数)的条件认为是成立的,所以可以找到记录。
SQL> select rownum,id,name from student where rownum <3;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
1 200001 张一
        2 200002 王二
综上几种情况,可能有时候需要查询rownum在某区间的数据,那怎么办呀从上可以看出rownum对小于某值的查询条件是人为true的,rownum对于大于某值的查询条件直接认为是false的,但是可以间接的让它转为认为是true的。那就必须使用子查询。例如要查询rownum在第二行到第三行之间的数据,包括第二行和第三行数据,那么我们只能写以下语句,先让它返回小于等于三的记录行,然后在主查询中判断新的rownum的别名列大于等于二的记录行。但是这样的操作会在大数据集中影响速度。
SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;
        NO ID     NAME
---------- ------ ---------------------------------------------------
         2 200002 王二
         3 200003 李三
(4)rownum和排序
Oracle中的rownum的是在取数据的时候产生的序号,所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         3 200003 李三
         2 200002 王二
         1 200001 张一
         4 200004 赵四
可以看出,rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号,rowid也是顺序分配的。为了解决这个问题,必须使用子查询
SQL> select rownum ,id,name from (select * from student order by name);
    ROWNUM ID     NAME
---------- ------ ---------------------------------------------------
         1 200003 李三
         2 200002 王二
         3 200001 张一
         4 200004 赵四
这样就成了按name排序,并且用rownum标出正确序号(有小到大)

posted @ 2011-11-17 16:46 redcoatjk 阅读(312) | 评论 (0)编辑 收藏
 
仅为个人理解.请指正
Hibernate Session, 其作用无需多言.
运用中为避免资源消耗,一般都会手动封装一个HibernateUtil类(未使用Spring管理的前提下).
该类的作用使Hibernate加载配置文件config, 创建sessionFactory等只运行一次.
际运用中,经常需要将当前线程和session绑定.一般的用法为使用ThreadLocal: 在HibernateUtil类中封装hibernate的管理.通过openSession取得
session,并将其放入ThreadLocal变量中. 这样业务逻辑中仅需通过工具类取得当前线程对应的session.使用完毕后,调用工具类closeSession方法将
session关闭,当前线程的ThreadLocal变量置为NULL. 保证线程归还线程池复用后,ThreadLocal为空,以免出现导致其他线程访问到本线程变量.
后,Hibernate的SessionFactory提供获取session的新方法getCurrentSession (获得与当前线程绑定的session). 内部通过代理封装,此方式得到的session
不仅和当前线程绑定,也无需手动开关. 默认在事务提交之后,session自动关闭. 需注意的是,必须在事务开启的前提之下才可使用此种方式获得的session.
此外hibernate.cfg.xml配置文件中也许配置
<property name="current_session_context_class">thread</property> 基于线程
了,引入Spring之后.sessionfactory的创建等都交给spring管理.Spring也提供了HibernateTemplate,HibernateDaoSupport这样的封装方法.
用户可以不再考虑session的管理,事务的开启关闭.只需配置事务即可.
而所谓session关闭后,因延迟加载导致前台无法显示的问题以往解决方式为强制全部加载,现在也可通过在web.xml中配置
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter来解决.



------------------------------以下内容为工地资料-------------------------------------------------------------------------------
OpenSession : 手动打开,需手动关闭.[所以代码中充斥着try catch --sf.openSession --打开事务,提交-回滚 finall关闭session的代码]
threadlocal : hibernate给出的提示. 在HibernateUtil工具类中,new出threadlocal ,放入opensession.这样可以使当前线程绑定session.
使用后需关闭session,将threadlocal中session变量置为null .
3  getCurrentSession: hibernate3的新特性. 无需手动关闭session,自动获取当前线程的session,若无则新建之. 需在配置文件中配置thread属性.表明和当前线程绑定.
    参考网友资料,getCurrentSession模式,内部开启了session自动提交的功能且使用getCurrentSession的session,及时做load操作,也需要打开事务.
Title

1 getCurrentSession创建的session会和绑定到当前线程,而openSession不会。

2 getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭

这里getCurrentSession本地事务(本地事务:jdbc)时 要在配置文件里进行如下设置

 * 如果使用的是本地事务(jdbc事务)
 <property name="hibernate.current_session_context_class">thread</property>
 * 如果使用的是全局事务(jta事务)
 <property name="hibernate.current_session_context_class">jta</property>

getCurrentSession () 使用当前的session
openSession()         重新建立一个新的session

在一个应用程序中,如果DAO 层使用Spring 的hibernate 模板,通过Spring 来控制session 的生命周期,则首选getCurrentSession ()。

使用Hibernate的大多数应用程序需要某种形式的“上下文相关的” session,特定的session在整个特定的上下文范围内始终有效。然而,对不同类型的应用程序而言,要为什么是组成这种“上下文”下一个定义通常 是困难的;不同的上下文对“当前”这个概念定义了不同的范围。在3.0版本 之前,使用Hibernate的程序要么采用自行编写的基于 ThreadLocal的上下文session,要么采用HibernateUtil这样的辅助类,要么采用第三方框架(比如Spring或Pico), 它们提供了基于代理(proxy)或者基于拦截器(interception)的上下文相关session。从3.0.1版本开始,Hibernate增加了SessionFactory.getCurrentSession()方法。一 开始,它假定了采用JTA事务,JTA事务定义了当前session的范围和上下文(scope and context)。Hibernate开发团队坚信,因为有好几个独立的JTA TransactionManager实现稳定可用,不论是否被部署到一个J2EE容器中,大多数(假若不是所有的)应用程序都应该采用JTA事务管理。 基于这一点,采用JTA的上下文相关session可以满足你一切需要。

更好的是,从3.1开始,SessionFactory.getCurrentSession()的后台实现是可拔插的。因此,我们引入了新的扩展 接口 (org.hibernate.context.CurrentSessionContext)和新的配置参数 (hibernate.current_session_context_class),以便对什么是“当前session”的范围和上下文(scope and context)的定义进行拔插。

请参阅 org.hibernate.context.CurrentSessionContext接口的Javadoc,那里有关于它的契约的详细讨论。它定义 了单一的方法,currentSession(),特定的实现用它来负责跟踪当前的上下文session。Hibernate内置了此接口的两种实现。

org.hibernate.context.JTASessionContext - 当前session根据JTA来跟踪和界定。这和以前的仅支持JTA的方法是完全一样的。详情请参阅Javadoc。

org.hibernate.context.ThreadLocalSessionContext - 当前session通过当前执行的线程来跟踪和界定。详情也请参阅Javadoc。

这两种实现都提供了“每数据库事务对应一个session”的编程模型,也称作每次请求一个session。Hibernate session的起始和终结由数据库事务的生存来控制。假若你采用自行编写代码来管理事务(比如,在纯粹的J2SE,或者 JTA/UserTransaction/BMT),建议你使用Hibernate Transaction API来把底层事务实现从你的代码中隐藏掉。如果你在支持CMT的EJB容器中执行,事务边界是声明式定义的,你不需要在代码中进行任何事务或 session管理操作。请参阅第 11 章 事务和并发一节来阅读更多的内容和示例代码。

hibernate.current_session_context_class 配置参数定义了应该采用哪个org.hibernate.context.CurrentSessionContext实现。注意,为了向下兼容,如果未 配置此参数,但是存在org.hibernate.transaction.TransactionManagerLookup的配 置,Hibernate会采用org.hibernate.context.JTASessionContext。一般而言,此参数的值指明了要使用的实 现类的全名,但那两个内置的实现可以使用简写,即"jta"和"thread"。

1、getCurrentSession()与openSession()的区别?

* 采用getCurrentSession()创建的session会绑定到当前线程中,而采用openSession()
创建的session则不会
* 采用getCurrentSession()创建的session在commit或rollback时会自动关闭,而采用openSession()
创建的session必须手动关闭
2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置:
* 如果使用的是本地事务(jdbc事务)
<property name="hibernate.current_session_context_class">thread</property>
* 如果使用的是全局事务(jta事务)
<property name="hibernate.current_session_context_class">jta</property>

利于ThreadLocal模式管理Session
   早在Java1.2推出之时,Java平台中就引入了一个新的支持:java.lang.ThreadLocal,给我们在编写多线程程序
   时提供了一种新的选择。ThreadLocal是什么呢?其实ThreadLocal并非是一个线程的本地实现版本,它并不是一个Thread,
   而是thread local variable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)
   其实的功用非常简单,就是为每一个使用某变量的线程都提供一个该变量值的副本,是每一个线程都可以独立地改变自己的副本,
   而不会和其它线程的副本冲突。从线程的角度看,就好像每一个线程都完全拥有一个该变量。
   ThreadLocal是如何做到为每一个线程维护变量的副本的呢?其实实现的思路很简单,在ThreadLocal类中有一个Map,
   用于存储每一个线程的变量的副本。比如下面的示例实现(为了简单,没有考虑集合的泛型):
public class HibernateUtil {

public static final ThreadLocal session =new ThreadLocal();

public static final SessionFactory sessionFactory;
   static {
      try {
        sessionFactory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) {
           throw new ExceptionInInitializerError(ex);
      }   
}

     public static Session currentSession() throws HibernateException {
        Session s = session.get();
        if(s == null) {
          s = sessionFactory.openSession();
          session.set(s);
           }
         return s;
       }

    public static void closeSession() throws HibernateException {
           Session s = session.get();
        if(s != null) {
            s.close();
        }
        session.set(null);
    }
}

以下为ThreadLocal的参考资料
Title

 最近由于需要用到ThreadLocal,在网上搜索了一些相关资料,发现对ThreadLocal经常会有下面几种误解

 一、ThreadLocal是java线程的一个实现
      ThreadLocal的确是和java线程有关,不过它并不是java线程的一个实现,它只是用来维护本地变量。针对每个线程,提供自己的变量版本,主要是为了避免线程冲突,每个线程维护自己的版本。彼此独立,修改不会影响到对方。

 二、ThreadLocal是相对于每个session的

        ThreadLocal顾名思义,是针对线程。在java web编程上,每个用户从开始到会话结束,都有自己的一个session标识。但是ThreadLocal并不是在会话层上。其 实,Threadlocal是独立于用户session的。它是一种服务器端行为,当服务器每生成一个新的线程时,就会维护自己的 ThreadLocal。对于这个误解,个人认为应该是开发人员在本地基于一些应用服务器测试的结果。众所周知,一般的应用服务器都会维护一套线程池,也 就是说,对于每次访问,并不一定就新生成一个线程。而是自己有一个线程缓存池。对于访问,先从缓存池里面找到已有的线程,如果已经用光,才去新生成新的线 程。所以,由于开发人员自己在测试时,一般只有他自己在测,这样服务器的负担很小,这样导致每次访问可能是共用同样一个线程,导致会有这样的误解:每个 session有一个ThreadLocal

 三、ThreadLocal是相对于每个线程的,用户每次访问会有新的ThreadLocal

  理论上来说,ThreadLocal是的确是相对于每个线程,每个线程会有自己的ThreadLocal。但是上面已经讲到,一般的应用服 务器都会维护一套线程池。因此,不同用户访问,可能会接受到同样的线程。因此,在做基于TheadLocal时,需要谨慎,避免出现 ThreadLocal变量的缓存,导致其他线程访问到本线程变量 .[senngr:HibernateUtil工具类中,一般都是通过closesession的方法,里面将opensession对应的session关闭.并将ThreadLocal变量置为NULL.这样线程池中如果再将这个线程分配给别人,对应的ThreadLocal是干净的.]

 四、对每个用户访问,ThreadLocal可以多用
        可以说,ThreadLocal是一把双刃剑,用得来的话可以起到非常好的效果。但是,ThreadLocal如果用得不好,就会跟全局变量一样。代码不 能重用,不能独立测试。因为,一些本来可以重用的类,现在依赖于ThreadLocal变量。如果在其他没有ThreadLocal场合,这些类就变得不 可用了。个人觉得ThreadLocal用得很好的几个应用场合,值得参考

  1、存放当前session用户:quake want的jert

  2、存放一些context变量,比如webwork的ActionContext

  3、存放session,比如Spring hibernate orm的session

posted @ 2011-11-02 01:37 redcoatjk 阅读(17685) | 评论 (3)编辑 收藏
 
http://space.itpub.net/9252210/viewspace-594453
今天在做数据导出的时候,由于用户名的密码使用的是特殊字符,所以遇到了错误代码:“EXP-00056: 遇到 ORACLE 错误 12154”,网上查找原因,需要用引号扩起来,但是os不同,方式也不同:

    windows os: exp username/"""password"""@devdb --3个双引号扩密码

    linux/unix os: exp 'username/"password"@devdb' --1个双引号扩密码,1个单引号扩全部

    实验结果如下:
1.创建带有特殊字符密码的用户
C:\Documents and Settings\Home>sqlplus /nolog
SQL*Plus: Release 10.2.0.1.0 - Production on 星期四 5月 7 17:37:36 2009
Copyright (c) 1982, 2005, Oracle.  All rights reserved.
SQL> connsys/oracle@devdbas sysdba
已连接。
SQL> create user exp identified by "12345!@#$%";
用户已创建。
SQL> grant connect, resource to exp;
授权成功。
SQL> conn exp/"12345!@#$%"@devdb2
已连接。
SQL> create table table1 as select * from dual;
表已创建。
SQL> exit
2.windows os导出测试
C:\Documents and Settings\Home>expexp/12345!@#$%@devdbfile=c:\exp.dmp wner=exp
Export: Release 9.2.0.1.0 - Production on 星期四 5月 7 17:39:42 2009
Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.
EXP-00056: 遇到 ORACLE 错误 12154
ORA-12154: TNS: 无法处理服务名
EXP-00000: 导出终止失败
C:\Documents and Settings\Home>exp exp/"12345!@#$%"@devdb2file=c:\exp.dmp wner=exp
Export: Release 9.2.0.1.0 - Production on 星期四 5月 7 17:39:57 2009
Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.
EXP-00056: 遇到 ORACLE 错误 12154
ORA-12154: TNS: 无法处理服务名
EXP-00000: 导出终止失败
C:\Documents and Settings\Home>exp exp/"""12345!@#$%"""@devdb2file=c:\exp.dmp wner=exp
Export: Release 9.2.0.1.0 - Production on 星期四 5月 7 17:41:54 2009
Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.
连接到: Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - Production
With the Partitioning, Real Application Clusters, OLAP, Data Mining
and Real Application Testing options
已导出 ZHS16GBK 字符集和 AL16UTF16 NCHAR 字符集
. 正在导出 pre-schema 过程对象和操作
. 正在导出用户 EXP 的外部函数库名称
. 导出 PUBLIC 类型同义词
. 导出私有类型同义词
. 正在导出用户 EXP 的对象类型定义
即将导出 EXP 的对象 ...
. 正在导出数据库链接
. 正在导出序号
. 正在导出群集定义
. 即将导出 EXP 的表通过常规路径 ...
. . 正在导出表                          TABLE1          1 行被导出
. 正在导出同义词
. 正在导出视图
. 正在导出存储的过程
. 正在导出运算符
. 正在导出引用完整性约束条件
. 正在导出触发器
. 正在导出索引类型
. 正在导出位图, 功能性索引和可扩展索引
. 正在导出后期表活动
. 正在导出实体化视图
. 正在导出快照日志
. 正在导出作业队列
. 正在导出刷新组和子组
. 正在导出维
. 正在导出 post-schema 过程对象和操作
. 正在导出统计
在没有警告的情况下成功终止导出。

3.linux/unix os导出测试
[oracle@rac2 ~]$ expexp/12345!@#$%@devdbfile=./exp.dmp wner=exp
-bash:!@#$%@devdb: event not found
[oracle@rac2 ~]$ exp exp/"""12345!@#$%"""@devdbfile=./exp.dmp wner=exp
-bash:!@#$%"""@devdb: event not found
[oracle@rac2 ~]$exp 'exp/"12345!@#$%"@devdb'file=./exp.dmp wner=exp 
Export: Release 10.2.0.4.0 - Production on Thu May 7 19:21:32 2009 
Copyright (c) 1982, 2007, Oracle.  All rights reserved. 
Connected to: Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - Production
With the Partitioning, Real Application Clusters, OLAP, Data Mining
and Real Application Testing options
Export done in US7ASCII character set and AL16UTF16 NCHAR character set
server uses ZHS16GBK character set (possible charset conversion)
. exporting pre-schema procedural objects and actions
. exporting foreign function library names for user EXP
. exporting PUBLIC type synonyms
. exporting private type synonyms
. exporting object type definitions for user EXP
About to export EXP's objects ...
. exporting database links
. exporting sequence numbers
. exporting cluster definitions
. about to export EXP's tables via Conventional Path ...
. . exporting table                         TABLE1          1 rows exported
. exporting synonyms
. exporting views
. exporting stored procedures
. exporting operators
. exporting referential integrity constraints
. exporting triggers
. exporting indextypes
. exporting bitmap, functional and extensible indexes
. exporting posttables actions
. exporting materialized views
. exporting snapshot logs
. exporting job queues
. exporting refresh groups and children
. exporting dimensions
. exporting post-schema procedural objects and actions
. exporting statistics
Export terminated successfully without warnings.

posted @ 2011-10-19 17:03 redcoatjk 阅读(681) | 评论 (0)编辑 收藏
 

关于group by 的应用问题  

数据库内容为下面


 

写一SQL得出下面内容:


 

贴出SQL结果如下:(MySQL版本)

create table gosin_temp(rq varchar(10),shengfu nchar(1));

insert into gosin_temp values('2009-05-09','胜');
insert into gosin_temp values('2009-05-09','胜');
insert into gosin_temp values('2009-05-09','负');
insert into gosin_temp values('2009-05-09','负');
insert into gosin_temp values('2009-05-10','胜');
insert into gosin_temp values('2009-05-10','负');
insert into gosin_temp values('2009-05-10','负');

select * from gosin_temp;

得到结果的SQL:
select a1.rq,a1.胜,b1.负 from
(select a.rq, count(a.shengfu) 胜 from gosin_temp a where a.shengfu='胜' group by a.rq) a1,
(select b.rq, count(b.shengfu) 负 from gosin_temp b where b.shengfu='负' group by b.rq) b1
where a1.rq = b1.rq

类似的题目还有很多,如:

   胜 负
1 a b
2 b a
3 b a

要求写一SQL语句,输出如下结果:
   胜 负
a 1 2
b 2 1

其实都一样 只要熟悉使用group by 就不觉得难了。

posted @ 2011-08-25 17:12 redcoatjk 阅读(213) | 评论 (0)编辑 收藏
 
摘自:   http://www.iteye.com/topic/766418

-----------------------------------------
1,什么是Servlet
2,Servlet有什么作用
3,Servlet的生命周期
4,Servlet怎么处理一个请求
5,Servlet与JSP有什么区别
6,Servlet里的cookie技术
7,Servlet里的过滤器
8,Servlet里的监听器

 


一,什么是Servlet?


Servlet是一个Java编写的程序,此程序是基于Http协议的,在服务器端运行的(如tomcat),

 

是按照Servlet规范编写的一个Java类。



二,Servlet有什么作用?


主要是处理客户端的请求并将其结果发送到客户端。



三,Servlet的生命周期?


Servlet的生命周期是由Servlet的容器来控制的,它可以分为3个阶段;初始化,运行,销毁。

初始化阶段:


1,Servlet容器加载servlet类,把servlet类的.class文件中的数据读到内存中。


2,然后Servlet容器创建一个ServletConfig对象。ServletConfig对象包含了Servlet的初始化配置信息。


3,Servlet容器创建一个servlet对象。


4,Servlet容器调用servlet对象的init方法进行初始化。



运行阶段:


当servlet容器接收到一个请求时,servlet容器会针对这个请求创建servletRequest和servletResponse对象。

 

然后调用service方法。并把这两个参数传递给service方法。Service方法通过servletRequest对象获得请求的

 

信息。并处理该请求。再通过servletResponse对象生成这个请求的响应结果。然后销毁servletRequest和

 

servletResponse对象。我们不管这个请求是post提交的还是get提交的,最终这个请求都会由service方法来处理。


web服务器接受到一个http请求后,web服务器会将请求移交给 servlet容器,servlet容器首先对所请求的URL进行解析并根据
web.xml 配置文件找到相应的处理servlet,同时将request、response对象传递给它,servlet通过request对象可知道客户端
的请求 者、请求信息以及其他的信息等,servlet在处理完请求后会把所有需要返回的信息放入response对象中并返回到客户端,
servlet一旦处理 完请求,servlet容器就会刷新response对象,并把控制权重新返回给web服务器。

 


销毁阶段:


当Web应用被终止时,servlet容器会先调用servlet对象的destrory方法,然后再销毁servlet对象,

 

同时也会销毁与servlet对象相关联的servletConfig对象。我们可以在destroy方法的实现中,释放

 

servlet所占用的资源,如关闭数据库连接,关闭文件输入输出流等。



在这里该注意的地方:


在servlet生命周期中,servlet的初始化和和销毁阶段只会发生一次,而service方法执行的次数则取决于servlet被客户

 

端访问的次数

 

 


四,Servlet怎么处理一个请求?


当用户发送一个请求到某个Servlet的时候,Servlet容器会创建一个ServletRequst和ServletResponse对象。

 

在ServletRequst对象中封装了用户的请求信息,然后Servlet容器把ServletRequst和ServletResponse对象

 

传给用户所请求的Servlet,Servlet把处理好的结果写在ServletResponse中,然后Servlet容器把响应结果传

 

给用户。

 


五,Servlet与JSP有什么区别?


1,jsp经编译后就是servlet,也可以说jsp等于servlet。


2,jsp更擅长页面(表现)。servlet更擅长逻辑编辑。 (最核心的区别)。


3,在实际应用中采用Servlet来控制业务流程,而采用JSP来生成动态网页.在struts框架中,

 

JSP位于MVC设计模式的视图层,而Servlet位于控制层。

 


六,Servlet里的cookie技术?


cookies是一种WEB服务器通过浏览器在访问者的硬盘上存储信息的手段,是由Netscape公司开发出来的。


cookie技术的好处:


    1,Cookie有效期限未到时,Cookie能使用户在不键入密码和用户名的情况下进入曾经浏览过的一些站点。


    2,Cookie能使站点跟踪特定访问者的访问次数、最后访问时间和访问者进入站点的路径。
   
创建一个cookie

Java代码  收藏代码
  1. //里面的两个参数分别是cookie的名和cookie的值  
  2.   
  3. response.addCookie(new Cookie("abc","10000000"));  

 

使用cookie

Java代码  收藏代码
  1. Cookie[] cook =request.getCookies();//用一个Cookie数组来接收  
  2.   
  3. for(int j=0;j<cook.length;j++){//通过循环来打印Cookie  
  4.   
  5.         cook[j].getName()://取cookie的名    
  6.         cook[j].getValue()://去cookie的值  
  7.   
  8. }  
 


七,Servlet里的过滤器?


过滤器的主要作用


1,任何系统或网站都要判断用户是否登录。


2,网络聊天系统或论坛,功能是过滤非法文字


3,统一解决编码


(2)怎么创建一个过滤器:

 

1,生成一个普通的class类,实现Filter接口(javax.servlet.Filter;)。


2,重写接口里面的三个方法:init,doFilter,destroy。


3,然后在web.xml配置过滤器。



八,Servlet里的监听器?


监听器的作用:自动执行一些操作。

三种servlet监听器:

 

对request的监听。对session的监听。对application的监听。

怎么创建一个session监听器:


1,生成一个普通的class类,如果是对session的监听,则实现HttpSessionListener。


2,然后重写里面的五个方法:

 

Java代码  收藏代码
  1. public void sessionCreated(HttpSessionEvent arg0) {} // 创建  
  2.   
  3. public void sessionDestroyed(HttpSessionEvent arg0) {} // 销毁  
  4.   
  5. public void attributeAdded(HttpSessionEvent arg0) {} // 增加  
  6.   
  7. public void attributeRemoved(HttpSessionEvent arg0) {} // 删除  
  8.   
  9. public void attributeReplaced(HttpSessionEvent arg0) {} // 替换 
posted @ 2011-08-25 15:41 redcoatjk 阅读(217) | 评论 (0)编辑 收藏
 
这个写的不错.有的没看懂.
目前没时间细看,暂时先转载.
摘自:
http://www.jdon.com/artichect/state.htm

---------------------------------------------------

板桥里人 http://www.jdon.com 2006/1/2(转载请保留)

  这是一个实战中非常重要但是容易被忽视的概念,说它重要,是因为它比数据库重要;说它容易被忽视也是同样的原因,它经常被数据库概念替代。

  如果你经验和经历中没有状态这个概念,极端地说:可能你的Java系统经验还未积累到一定程度,状态是每个Java程序员深入Java系统后必然碰到的问题。

  本文我想试图表达的是:状态分两种:活动的状态对象和持久化的状态。而数据库中的数据只是状态的一种持久化结果,而Java系统 运行时,我们更多的可能是和一种活动的状态打交道,这种活动的状态存在内存中,而不是持久化到硬盘上,当然,需要时你可以通过数据库/文件持久化到硬盘上。

  但是,如果你以数据库数据替代状态,那么就可能导致数据库的频繁访问,而且 你的系统会变成一个非对象化的、紧耦合、到处是分散数据块的糟糕系统。这样的系统并不比传统的两层结构好到哪里!也不会比Jsp里嵌入Java代码伪三层系统高明到什么地方。

什么是状态?

  只要有对象就可能有状态,任何一个对象活动时,都有自己的状态属性,类的 字段属性极有可能成为状态,我们现在经常使用的Domain model其实就是一种 包含状态的对象,如果你对状态没有深入掌握,就不可能真正掌握对象系统特点,或者是Domain Model的执行情况。

  对于初学者,经常会疑问:我是将数据放在HttpSession中还是Request中,这里 其实已经开始接触状态,一旦你接触状态,你就要开始小心,因为你可能会将内存泄漏的恶魔导引进来。

  内存泄漏的恶魔爆发时刻取决于你状态的生存周期和系统并发访问量。

  状态的生存周期也就是包含这个状态的对象的生命周期,在简单系统中,我们只 需要通过new创建对象,然后它的消亡就会依靠JVM垃圾回收机制回收,但是事情会这么简单吗?

  状态的危险还会发生在多线程环境下,当多个线程对同一个内存中状态写操作时,这时怎么办?如果这个状 态持久化在数据库中,我们会依赖数据库提供的强大事务机制防止这种并发死锁,但是如果是在内存中,你就很难办,因此,我们就尽量避免发生这种多线程同时访 问一个状态的现象,而Singleton单例模式极容易发生这种现象,因此实践中,单例模式是J2EE开发中需要避免的,相关帖子讨论见:
http://www.jdon.com/jive/article.jsp?forum=91&thread=17578

  我们接触的Web容器或Jsp/Servlet本质就是一个多线程,这也是很多初学者不知道的, 因为多线程编程是复杂或困难的,因此才有jsp/Servlet这样的上层封装,但是我们使用他们
时,实际在进行多线程编程。

  生命周期和多线程并发使得我们简单的面向对象系统变得异常复杂和难以掌握起来。下面我从这个两个角度,给出两种模式思维解决之道。

生命周期(Scope)

  生命周期(Scope)就是指状态的活动周期,状态对象是什么时候被创建;然后什么时候被销毁,很显然,如果状态对象还没有被创建或已经被销毁,你再 访问这个状态对象可能失败,而状态的生命周期控制是可能散落在运行程序的各个地方,如果不象状态模式那样进行统一控制,有可能整个系统是危机四伏的。

  状态的生命周期其实就是对象生命周期,更加细化地说:是Domain Model这个对象的生命周期。这在一个以领域模型为驱动的设计概念中不可回避的课题,而领域模型实战的复杂性就复杂在此。

  状态的生命周期在J2EE中目前有三种:Request/Session和 Application,Request是每个客户端发出的一次请求,这是J2EE系统中最基本的事件激活单元, 当服务器端推出一个页面到客户端时,意味着这个Request的结束。那么如果我们的状态保存在Request中,意味着在request结束之前,这个 请求经历的任何一个环节都可以对这个状态(对象)进行操作。(掌握这个原理,对于你学习Struts和JSF很有帮助)

  如果是Session,则一直和该客户端有关,只要是该客户端发出的每次request的任何环节都可以对这个状态(对象)进行操作。

  如果是Application,则意味着这个状态是当前Web项目的全局状态。

  这三种状态形式都是以将状态保存在内存中形式存在的,是和持久化状态相对的。是一种内存活动状态。

  生命周期的选取当然是越短越好,这样,这个状态对象就可以被自动销毁,从而避免了
大访问量下的内存泄漏,但是在大访问量下,对象频繁创建和销毁是耗费性能的。

  那么,我们可能经常使用HttpSession来保存状态,这时你极有可能造成内存泄漏,我经常在 Jdon论坛上看到将很多数据库数据暂时保存在HttpSession中想法,这是相当危险的,因为一旦并发用户很多,相当多的HttpSession包 含了状态,而状态中有可能有更多其他引用,因此内存很快会爆满,或者垃圾回收机制频繁启动,造成应用系统运行暂停或缓慢。

  当你将状态放入HttpSession时,难道没有考虑将其手工消除吗?你要知道所有Web容器 (Tomcat/Weblogic等)都不会自动替你清除那些你可能不用的状态对象啊。如果每个人只管新增元素,不管重整或管理,这个系统能不变得混乱 吗?代码上这种现象我们是通过Refactoring等结构/行为模式来解决,那么在运行时的状态管理呢?

  状态管理模式或者说对象管理模式正是解决这种问题的。

   按照该模式,你必须手工自己管理放在HttpSession的状态,比如你为每个HttpSession
设立一个状态容器最大尺寸,当超过这个尺寸时,你需要将不用的状态从容器去除, 但是如果这个客户端在Session失效期内又来访问这个状态怎么办?那么你可能需要先临时将状态序列化保存到硬盘上,等Session失效期到达后再真正删除。

  是不是觉得很麻烦?
  捷径是有:
  1. 尽量少使用HttpSession保存状态,这对集群环境也是有利的,见该贴讨论:
http://www.jdon.com/jive/article.jsp?forum=121&thread=22282
那么这些状态放在哪里?使用Application的缓存中,

  2. 使用状态管理中间件,目前有几个选择:EJB的有态Bean;NanoContainer之类状态相关的微容器。那么Spring可以吗?目前没有发现有 该功能,甚至在Spring容器内无法直接使用Session性质的状态,只能通过线程级别的ThreadLocal来实现(对不起,你又要开始回到远古 的汇编线程时代了);而Jdon框架则可以。

  下面我们谈谈Application的状态,在这个范围内,一个对象状态可以被多个用户反复访问,在这个级别,状态类似数据库中数据,因为可以使用数据库来替代这个级别的状态,所以将状态放入缓存这个深层次技术被大多数初学者忽视了,甚至产生了对数据库依赖心理。

缓存中的状态

  虽然我们将状态保存在Application中,但是我们不可避免还是遇到Session同样的状态管理问题,这个问题所幸的是有专门缓存中间件解决 了,当然,在一个多服务器集群系统,如果一个客户端在一个服务器中存放了状态,那么能否在另外一个服务器的内存中访问到呢?回答是肯定的,前提是你必须使 用分布式缓存系统。

  目前分布式缓存系统是靠EJB服务器完成,当JBoss 5在2006变成完全解耦、可肢解时,
我们就可以使用原本只支持EJB的JBoss分布式缓存系统来支持我们的普通JavaBeans了(POJO)。这其中目前可能会花费一些力气,因为还没有一个统一的POJO构件接口标准,我相信以后
可能会有。

  如果你不想花费力气,而且可能就只是一台服务器,可以通过双核芯片提升性能,那么单态缓存如果实现?很简单,使用一个缓存产品如OsCache等,将其设定保存在 Application中,或者在web.xml中进行一下简单的配置即可。

  但是,这时你可能碰到另外一个问题:状态的唯一标识,如何通过唯一标识从缓存中那么
多对象状态中取出你要的那一个呢?比较琐碎。

  有没有一个框架帮助你省却这些麻烦,当然推荐Jdon Framework,只要将包含状态的类(主要是Domain Model)继承特定的类或接口(接口在1.4版本实现)即可,这个类的对象运行时就会被缓存或从缓存中读取,再也无需你照料缓存了,就这么简单。

  当然,Jdon Framework的底层缓存器是可以被替代,使用你喜欢的缓存产品,因为jdon
Framework是基于Ioc设计,构件之间是完全解耦、可彻底肢解,能够通过配置替代和更换的。
如果你不明白这个道理,需要好好研究一下Ioc模式带给我们革命性的新变化。

  从以上也可以看出:java复杂性还在于我们需要在编码时,却要想象其运行时的情形。而这种翻译联想没有深厚的实践功底,是很难顺利完成的。

状态管理中间件

  自从J2EE开辟中间件时代以来,就有相当多的高级中间件提供与具体应用无关的通用功能,状态管理中间件很早就有之,EJB的有态Session Bean是一个代表。

  一个中间件不但要有良好的松耦合设计,我们暂时称为静态设计;更要有优秀的动态设计,例如状态管理就属于一种动态设计。

  当然,如果你比较谦虚,不但要选择一些静态设计很好的框架或中间件;而且还要依赖一些拥有良好的动态运行管理的中间件。

  EJB无论是EJB1.X/EJB2.X/EJB3.X.在状态管理上要更加优秀,当然EJB3.X又吸收了优秀的静态设计概念,但是因为需要有一个具体服务器实现过程,这个过程中存在一些陷阱,如In-Box问题等。

  Spring无疑是一个静态设计非常优秀框架,它一直在AOP上孜孜不倦,力图探索一条从AOP角度进行动态运行管理干预捷径,相信会有惊人结果,当然,这种细粒度的AOP需要实践检验,当然如果整入JDK 6.0就更好。

  而Jdon Framework则试图在目前两者之间寻求了一个平衡,既有Ioc/AOP优秀的静态设计,虽然在AOP上不及Spring前卫;但提供了切实Session和Cache状态管理;

  如果你不需要EJB的分布式多服务器集群功能;又不是AOP的超级粉丝,无疑使用Jdon Framework之类的框架无疑是简化方便的。

状态设计的难点

  最后,我不得不重申,并不是有了良好的状态管理框架就可以高枕无忧了,状态的设计其实是我们每个项目必须面临的可变课题,如果状态复杂了可以使用状态模式对付,可惜往往状态不够复杂。

  一个对象本身属性和状态是应该耦合在一起,还是进行分离,属性和状态没有明显的泾渭分明的界限,我们举一个例子:

  论坛Forum这个对象,它有一些字段属性,如论坛名称、论坛描述,还有其他一些相关属性:如该论坛 的最新发帖;该论坛的发贴量,后两者好像也是论坛字段,但是他们可能经常变化的,应该属于状态,那么状态和Forum这个主体对象是什么关系?是将该论坛 的最新发帖和该论坛的发贴量两个字段并入Forum这个Domain Model中,还是应该单独建立一个状态对象?如果进行分离,分离的依据是什么?

  当然,这里分离的依据是因为对象的生存周期不同。对于我们熟悉的课题,我们能够马上分辨出其中的生存周期,如果是不熟悉领域的建模呢?

  所以,大家已经明白:状态设计的难点是:如何粒度细化地创建模型对象;然后分辨出其中动态的状态性质。这是域建模实战中一个难点。

  很多人问我:你提倡的域建模、设计模式和框架是什么意思?为什么说他们是Java开发设计的三件宝呢?或者说三个典型知识点呢?我想通过本篇我已经通过状态这个概念稍微解释了域建模的一些特点。

  当前,MDA中的四色原型模式Archetype将帮助我们更好地分辨出类的属性、状态和行为,这是一场带来以后十年的软件革命,
posted @ 2011-08-25 15:38 redcoatjk 阅读(177) | 评论 (0)编辑 收藏
 

我对浏览器请求流程的理解:

(1) 访问流程:

(1.1) 系统运行在某web容器,Tomcat(其运行和weblogic不同,Tomcat只有一个进程).

      其预设有初始的线程数.

(1.2) 浏览器打开某网站,网站及给其分配一个sessionID(页面隐式的发起request, Tomcat

      某个特定的监听线程给予response一个sessionid). sessionid用以识别本次访问.

(1.3) 用户点击登录/注册, 浏览器发起一个新的request, Tomcat线程池中空闲的线程进行

       处理. 反馈结果于前台展现.如线程池中线程不足,Tomcat每次按照一定规则创建出更多的空闲线程(其初始值,增加值,及最大值依据配置文件/JDK/硬件).

posted @ 2011-08-25 11:37 redcoatjk 阅读(222) | 评论 (0)编辑 收藏
 
来源:
http://www.iteye.com/topic/960652
http://godsend-jin.iteye.com/blog/1004386
--------------------------------------------------------------------

最近在做登录和权限控制模块,用到了session,发现session的好多方法都不熟悉,而且以前也听说过JsessionId 之类session窃取的事,

对这些一直都是一知半解。今天索性google了很多资料,先上sun的官网去看session的文档了解一些方法,又找了别人关于session的看法。

总结如下:

      1,session是什么?  what

          session经常译为会话,以打电话为例,从开始拨号到挂断电话就是你会话的生存周期。

      2,session 做什么用的  why?

          首先举个例子:

                咖啡店举行 消费满5杯咖啡赠送一杯的活动,可每个人一次消费5杯的时候非常少。这时候有3种办法:

                1,店员看到每个顾客时都能记住其消费了多少杯,从而给其优惠,这是协议本身具有状态

                2,给每个顾客一个卡片,上面记录顾客的每次消费,这是客户端保存状态

                3,给每个顾客一个卡片,卡片上只有一个编号,顾客每次的消费记录在店里,这就是 服务端有状态

          而http本身是无状态的,所以我们只能使用2,3中方法,来保存一些信息。

          实际采用的是第3种方法,服务器段保存一次会话所有的信息,并生成一个唯一的id,这个id没有规律而且不会重复,将这个id传回到客户段,

保存到cookie中。每次访问服务器时,客户端都会偷偷将这个id传到服务器,服务器根据id查到这次会话保存的内容。就能实现会话中共享一些数据。

     3,session怎样创建和销毁 ? how

         session是保存在内存中的,所以会有一些性能上的影响。因此本着这个原则,session是只有在使用到的时候才会被创建,如果始终没有用到

session,这个session是永远不会被创建的。

        比如: 访问servlet ,只要你代码中没有 request.getSession()或request.getSession(true);这两行是等价的,那session是不会创建。

又 当你访问静态页面时,根本不会生成servlet,所以也不会创建session。

       下面解释一些疑惑: session是第一次请求时创建的?

  大家都知道 jsp是被编译成servlet才执行的,问题就在jsp编译的过程。

 jsp中有个<%@ page session="true/false"%> 这个开关表示是否创建session,当你不写这行时,它会默认给你加上这句。所以会造成上面的疑惑。

当然还有一些标签中可能有getSession()操作,会产生一些不必要的session。

       session只能在服务端销毁,有三种途径: 1,到达session的最大请求间隔时间时,2,session。invalidate()

 3,服务器进程当掉。

       这里也有一些疑惑: 浏览器关闭时,session就会注销。

       首先浏览器关闭时,浏览器并没有给服务器发送任何消息,所以服务器不会知道浏览器何时关闭了。

 上面我们知道取得session 是因为浏览器cookie中有sessionid,而普通cookie通常会是会话cookie,也就是说浏览器关闭时,这个cookie会被注销,

所以当你再访问服务器时就没有sessionid了,所以造成session关闭了的假象,如果昵称通过特殊方法将sessionid传递给服务器,你会发现session还在。

如果想让cookie保存时间长一些,就需要手动指定cookie的过期时间

 

4,实际项目中的难点:

     1,浏览器禁用cookie

      这就没办法保存sessionid了,可以采用url重写,转发,加隐藏字段等方法来将sessionid传给服务器。

     如:  baidu.com:jsessionid=adfasdfasdfasdfasdfafdadf?asdfasdf

             baidu.com?jsessionid=asdfasdfasdfadsfad&&adfdf

 这根据服务器的不同实现,第一种可以将普通参数区分开。

 

     2,多人共用session的问题

        例: a 访问 baidu.com ,但他没有帐号,于是他将连接 baidu.com/login.jsp?jsessionid=adsfasdfad(这个a的sessionid) 发给B, B登录

后,a就相当于用b的帐号登录了。你们可以在在本地试试。

        解决方法: 当发现通过sessionid从url指定时, 创建一个新的session,将旧session的信息复制到 新sessoin中,然后将新session注销。

就能防止上面那种情况了。

    3,一个帐号多地方登录

       比如: 你用abc帐号登录了baidu.com,有打开了一个浏览器,又用abc帐号登录了一次。当不设计敏感操作时,这无所谓,而当你做一些敏感操

作时就必须禁止这样情况,防止同时操作,造成重复操作,或者数据损坏。

     解决方法: 监听session,将username和sessionid对应起来,当username再次登录时,注销掉以前的session,保存现在的session,这也是

一种比较不错的方案。

 

这是 sghcel 画的图,挺不错的:

 



其他:
 1session在何时被创建 
    一个常见的误解是以为session在有客户端访问时就被创建,然而事实是直到某server端程序调用 HttpServletRequest.getSession(true)这样的语句时
才被创建,注意如果
JSP没有显示的使用 <%@page session="false"%> 关闭session,则JSP文件在编译成Servlet时将会自动加上这样一条语句
HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。 

   
由于session会消耗内存资源,因此,如果不打算使用session,应该在所有的JSP中关闭它。


    2
session何时被删除
  综合前面的讨论,session在下列情况下被删除a.程序调用HttpSession.invalidate();b.距离上一次收到客户端发送的session id时间间隔超过了session
超时设置
;c.服务器进程被停止(非持久session


    3
、如何做到在浏览器关闭时删除session
Title
  严格的讲,做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作,然后向服务器发送
一个请求来删除
session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。


    4
、有个HttpSessionListener是怎么回事 

   
你可以创建这样的listener去监控session的创建和销毁事件,使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener
而不是相反。类似的与
HttpSession有关的listener还有 HttpSessionBindingListenerHttpSessionActivationListener HttpSessionAttributeListener 

    5
、存放在session中的对象必须是可序列化的吗 


 
不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。
Weblogic Serversession中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果session中有不可序列化的对象,
session销毁时会有一个Exception,很奇怪。


    6
、如何才能正确的应付客户端禁止cookie的可能性
 
    对所有的URL使用URL重写,包括超链接,formaction,和重定向的URL,具体做法参见[6]
http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770


    7
、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session 

   
参见第三小节对cookie的讨论,对session来说是只认id不认人,因此不同的浏览器,不同的窗口打开方式以及不同的cookie存储方式都会对这个问题
的答案有影响。
 

    8
、如何防止用户打开两个浏览器窗口操作导致的session混乱 
这个问题与防止表单多次提交是类似的,可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端,同时保存在session里,
客户端提交表单时必须把这个
id也返回服务器,程序首先比较返回的id与保存在session里的值是否一致,如果不一致则说明本次操作已经被提交过了。
可以参看《
J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口,一般不设置这个id,或者使用单独的id
以防主窗口无法操作,建议不要再
window.open打开的窗口里做修改操作,这样就可以不用设置。


    9
、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue 


做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变,需要向其他服务器进程复制新的session值。


   10HttpSession 和 hibernate session 有什么区别?
httpSession :

它的产生:J2EE的Web程序在运行的时候,会给每一个新的访问者建立一个HttpSession,这个Session是用户身份的唯一表示。注意,是容器

(Tomcat,Resin)自动创建的。

用途:存放这个用户的一些经常被用到的信息,例如:用户名,权限。例如在购物车程序里,存放用户买的商品。

销毁:一定时间(跟容器有关)内,用户无任何动作,session自动销毁。

得到的方法:
HttpSession session = request.getSession();
常用方法setAttribute
session.setAttribute(key,value);
这样在另一个jsp或者Servlet里,可以用
session.getAttribute(key);得到value
类似一个Map


hibernate session

它是hibernate操作数据库的一个句柄对象。它跟上面那个Session唯一的相似处就是名字有点像,其他没任何一样的地方。
它是hibernate表示操作数据库的一个会话

 

posted @ 2011-08-25 11:22 redcoatjk 阅读(1242) | 评论 (0)编辑 收藏
CALENDER
<2011年8月>
31123456
78910111213
14151617181920
21222324252627
28293031123
45678910

常用链接

留言簿(3)

随笔分类(22)

随笔档案(76)

文章分类(12)

文章档案(17)

搜索

  •  

积分与排名

  • 积分 - 249961
  • 排名 - 227

最新评论

评论排行榜


Powered By: 博客园
模板提供沪江博客