BlogJava-Jelver'Sky-文章分类-JSP/PHP

说说大型高并发高负载网站的系统架构

冰河快狼 — Wed, 09 Apr 2008 01:01:00 GMT

转载请保留出处：俊麟 Michael’s blog (http://www.toplee.com/blog/?p=71)
Trackback Url : http://www.toplee.com/blog/wp-trackback.php?p=71

　　我在CERNET做过拨号接入平台的搭建，而后在Yahoo&3721从事过搜索引擎前端开发，又在MOP处理过大型社区猫扑大杂烩的架构升级等工作，同时自己接触和开发过不少大中型网站的模块，因此在大型网站应对高负载和并发的解决方案上有一些积累和经验，可以和大家一起探讨一下。

　　一个小型的网站，比如个人网站，可以使用最简单的html静态页面就实现了，配合一些图片达到美化效果，所有的页面均存放在一个目录下，这样的网站对系统架构、性能的要求都很简单，随着互联网业务的不断丰富，网站相关的技术经过这些年的发展，已经细分到很细的方方面面，尤其对于大型网站来说，所采用的技术更是涉及面非常广，从硬件到软件、编程语言、数据库、WebServer、防火墙等各个领域都有了很高的要求，已经不是原来简单的html静态网站所能比拟的。

　　大型网站，比如门户网站。在面对大量用户访问、高并发请求方面，基本的解决方案集中在这样几个环节：使用高性能的服务器、高性能的数据库、高效率的编程语言、还有高性能的Web容器。但是除了这几个方面，还没法根本解决大型网站面临的高负载和高并发问题。

　　上面提供的几个解决思路在一定程度上也意味着更大的投入，并且这样的解决思路具备瓶颈，没有很好的扩展性，下面我从低成本、高性能和高扩张性的角度来说说我的一些经验。

1、HTML静态化
　　其实大家都知道，效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限管理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS是必不可少的。

　　除了门户和信息发布类型的网站，对于交互性要求很高的社区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像Mop的大杂烩就是使用了这样的策略，网易社区等也是如此。目前很多博客也都实现了静态化，我使用的这个Blog程序WordPress还没有静态化，所以如果面对高负载访问，www.toplee.com一定不能承受

　　同时，html静态化也是某些缓存策略使用的手段，对于系统中频繁使用数据库查询但是内容更新很小的应用，可以考虑使用html静态化来实现，比如论坛中论坛的公用设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中，这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这部分内容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求。

　　在进行html静态化的时候可以使用一种折中的方法，就是前端使用动态实现，在一定的策略下进行定时静态化和定时判断调用，这个能实现很多灵活性的操作，我开发的台球网站故人居(www.8zone.cn)就是使用了这样的方法，我通过设定一些html静态化的时间间隔来对动态网站内容进行缓存，达到分担大部分的压力到静态页面上，可以应用于中小型网站的架构上。故人居网站的地址：http://www.8zone.cn，顺便提一下，有喜欢台球的朋友多多支持我这个免费网站:)

2、图片服务器分离
　　大家知道，对于Web服务器来说，不管是Apache、IIS还是其他容器，图片是最消耗资源的，于是我们有必要将图片与页面进行分离，这是基本上大型网站都会采用的策略，他们都有独立的图片服务器，甚至很多台图片服务器。这样的架构可以降低提供页面访问请求的服务器系统压力，并且可以保证系统不会因为图片问题而崩溃。

　　在应用服务器和图片服务器上，可以进行不同的配置优化，比如Apache在配置ContentType的时候可以尽量少支持，尽可能少的LoadModule，保证更高的系统消耗和执行效率。

　　我的台球网站故人居8zone.cn也使用了图片服务器架构上的分离，目前是仅仅是架构上分离，物理上没有分离，由于没有钱买更多的服务器:)，大家可以看到故人居上的图片连接都是类似img.9tmd.com或者img1.9tmd.com的URL。

　　另外，在处理静态页面或者图片、js等访问方面，可以考虑使用lighttpd代替Apache，它提供了更轻量级和更高效的处理能力。

3、数据库集群和库表散列
　　大型网站都有复杂的应用，这些应用必须使用数据库，那么在面对大量访问的时候，数据库的瓶颈很快就能显现出来，这时一台数据库将很快无法满足应用，于是我们需要使用数据库集群或者库表散列。

　　在数据库集群方面，很多数据库都有自己的解决方案，Oracle、Sybase等都有很好的方案，常用的MySQL提供的Master/Slave也是类似的方案，您使用了什么样的DB，就参考相应的解决方案来实施即可。

　　上面提到的数据库集群由于在架构、成本、扩张性方面都会受到所采用DB类型的限制，于是我们需要从应用程序的角度来考虑改善系统架构，库表散列是常用并且最有效的解决方案。我们在应用程序中安装业务和应用或者功能模块将数据库进行分离，不同的模块对应不同的数据库或者表，再按照一定的策略对某个页面或者功能进行更小的数据库散列，比如用户表，按照用户ID进行表散列，这样就能够低成本的提升系统的性能并且有很好的扩展性。sohu的论坛就是采用了这样的架构，将论坛的用户、设置、帖子等信息进行数据库分离，然后对帖子、用户按照板块和ID进行散列数据库和表，最终可以在配置文件中进行简单的配置便能让系统随时增加一台低成本的数据库进来补充系统性能。

4、缓存
　　缓存一词搞技术的都接触过，很多地方用到缓存。网站架构和网站开发中的缓存也是非常重要。这里先讲述最基本的两种缓存。高级和分布式的缓存在后面讲述。

　　架构方面的缓存，对Apache比较熟悉的人都能知道Apache提供了自己的mod_proxy缓存模块，也可以使用外加的Squid进行缓存，这两种方式均可以有效的提高Apache的访问响应能力。

　　网站程序开发方面的缓存，Linux上提供的Memcached是常用的缓存方案，不少web编程语言都提供memcache访问接口，php、perl、c和java都有，可以在web开发中使用，可以实时或者Cron的把数据、对象等内容进行缓存，策略非常灵活。一些大型社区使用了这样的架构。

　　另外，在使用web语言开发的时候，各种语言基本都有自己的缓存模块和方法，PHP有Pear的Cache模块和eAccelerator加速和Cache模块，还要知名的Apc、XCache（国人开发的，支持！）php缓存模块，Java就更多了，.net不是很熟悉，相信也肯定有。

5、镜像
　　镜像是大型网站常采用的提高性能和数据安全性的方式，镜像的技术可以解决不同网络接入商和地域带来的用户访问速度差异，比如ChinaNet和EduNet之间的差异就促使了很多网站在教育网内搭建镜像站点，数据进行定时更新或者实时更新。在镜像的细节技术方面，这里不阐述太深，有很多专业的现成的解决架构和产品可选。也有廉价的通过软件实现的思路，比如Linux上的rsync等工具。

6、负载均衡
　　负载均衡将是大型网站解决高负荷访问和大量并发请求采用的终极解决办法。

　　负载均衡技术发展了多年，有很多专业的服务提供商和产品可以选择，我个人接触过一些解决方法，其中有两个架构可以给大家做参考。另外有关初级的负载均衡DNS轮循和较专业的CDN架构就不多说了。

6.1 硬件四层交换
　　第四层交换使用第三层和第四层信息包的报头信息，根据应用区间识别业务流，将整个区间段的业务流分配到合适的应用服务器进行处理。　第四层交换功能就象是虚IP，指向物理服务器。它传输的业务服从的协议多种多样，有HTTP、FTP、NFS、Telnet或其他协议。这些业务在物理服务器基础上，需要复杂的载量平衡算法。在IP世界，业务类型由终端TCP或UDP端口地址来决定，在第四层交换中的应用区间则由源端和终端IP地址、TCP和UDP端口共同决定。

　　在硬件四层交换产品领域，有一些知名的产品可以选择，比如Alteon、F5等，这些产品很昂贵，但是物有所值，能够提供非常优秀的性能和很灵活的管理能力。Yahoo中国当初接近2000台服务器使用了三四台Alteon就搞定了。

6.2 软件四层交换
　　大家知道了硬件四层交换机的原理后，基于OSI模型来实现的软件四层交换也就应运而生，这样的解决方案实现的原理一致，不过性能稍差。但是满足一定量的压力还是游刃有余的，有人说软件实现方式其实更灵活，处理能力完全看你配置的熟悉能力。

　　软件四层交换我们可以使用Linux上常用的LVS来解决，LVS就是Linux Virtual Server，他提供了基于心跳线heartbeat的实时灾难应对解决方案，提高系统的鲁棒性，同时可供了灵活的虚拟VIP配置和管理功能，可以同时满足多种应用需求，这对于分布式的系统来说必不可少。

　　一个典型的使用负载均衡的策略就是，在软件或者硬件四层交换的基础上搭建squid集群，这种思路在很多大型网站包括搜索引擎上被采用，这样的架构低成本、高性能还有很强的扩张性，随时往架构里面增减节点都非常容易。这样的架构我准备空了专门详细整理一下和大家探讨。

总结：
　　对于大型网站来说，前面提到的每个方法可能都会被同时使用到，Michael这里介绍得比较浅显，具体实现过程中很多细节还需要大家慢慢熟悉和体会，有时一个很小的squid参数或者apache参数设置，对于系统性能的影响就会很大，希望大家一起讨论，达到抛砖引玉之效。

　　转载请保留出处：俊麟 Michael’s blog (http://www.toplee.com/blog/?p=71)
Trackback Url : http://www.toplee.com/blog/wp-trackback.php?p=71

冰河快狼 2008-04-09 09:01 发表评论

不同Web主机上的Servlet之间数据对象的相互传输(转)

冰河快狼 — Thu, 13 Mar 2008 07:53:00 GMT

为什么要这样做
在目前所做的一个项目中，我们使用了两台独立的数据库服务器，出于安全方面的考虑，我们同时使用两台Web服务器分别操作这两个数据库。这就形成了这样的一个结构图：

由于数据库服务器A和服务库服务器B之间存在着数据的交换，而WEB服务器A并不能直接访问数据库服务器B，同理WEB服务器B也不能直接访问数据库服务器A。这样的交换只能是通过两台Web主机来进行。而在绝大多数时候，我们涉及的是较大规模的数据交换，使用带参数的格式显然不能满足我们的要求，这就涉及了不同Web主机上的Servlet之间数据对象的相互传输的问题。
使用通常的Application域或是Session域的javabean看上去不能满足我们的要求，虽然我们相信会有很多更为完美的方案可以解决这个问题，但是我们今天想看看如何直接通过HTTP连接来完成这样的传输。
首先对于我们的每一个独立的应用来说，两台WEB服务器都会存在一个主次的关系，情况也许是这样的：访问者访问WEB服务器A上的一个servlet A，而这个servlet A产生一个数据对象传输到WEB服务器B上的另一个servlet B，servlet B接收到这个数据对象后对其进行相应的处理，然后它可能还会生成另一个数据对象传输到servlet A中。这样的过程看上去有点象一个远程函数调用的概念。限于篇幅的限制，我们这里讨论一种较为简单的情况，test将passobject传输到test2，test2对passobject进行处理后将其传回到test。

简单示例的源码
passobject.java
首先，我们需要在两台WEB主机上分别建立对passobject的定义，在两台主机上的定义应该是完全一样，这样的类定义和我们通常使用并没有什么不同。只是这样的类必须实现序列化，也就是要实现Serializable：

    package test;
            import java.io.*;
            public class PassObject implements Serializable {
            String PassValue1;
            String PassValue2;
            public void setNewPassObject()
            {PassValue1="yzysynew";
            PassValue2="new";
            }
            public void setOldPassObject()
            {PassValue1="yzysyold";
            }
            }

test.java
在其中的一台web主机上建立。除去加注释的那几行，这完全是一个通常意义上的用于显示的servlet，不过那几行的内容看上去也许会有点让你眼花缭乱。这几行将数据对象传输到了另一台主机的test2中，并接收经过test2处理的数据对象。对于这里所涉及的一些不太常用的API，我们将会在最后一并说明。

            package test;
            import java.sql.*;
            import java.util.*;
            import javax.servlet.*;
            import javax.servlet.http.*;
            import javax.servlet.jsp.*;
            import javax.servlet.jsp.tagext.*;
            import java.io.*;
            import java.net.*;
            public class Test extends HttpServlet {
            public void doGet(HttpServletRequest request,
            HttpServletResponse response)
            throws IOException, ServletException
            {PassObject passobject = new PassObject();
            passobject.setNewPassObject();
            PrintWriter out = response.getWriter();
            out.println(passobject.PassValue1);
            out.println(passobject.PassValue2);
            //创建一个新的URL实例url
            URL url = new URL("http://141.56.16.8/examples/servlet/test.Test2");
            //根据url建立连接
            URLConnection con = url.openConnection();
            //设置该连接可写
            con.setDoOutput(true);
            //禁用cache
            con.setUseCaches(false);
            //取出输出流
            OutputStream outs=con.getOutputStream();
            //将该输出流转换为对象输出流
            ObjectOutputStream objout = new ObjectOutputStream(outs);
            //将要传输的对象写入该对象输出流中
            objout.writeObject(passobject);
            //取得返回的输入流
            InputStream in = con.getInputStream();
            //将该输入流定义为对象输入流
            ObjectInputStream objStream;
            objStream = new ObjectInputStream(in);
            //按指定类的格式读取输入流的内容
            try {
            passobject=(PassObject)objStream.readObject();
            out.println(passobject.PassValue1);
            out.println(passobject.PassValue2);
            }
            catch (java.lang.ClassNotFoundException ysy )
            {
            out.println("fail");
            }
            }
            public void doPost(HttpServletRequest request,
            HttpServletResponse response)
            throws IOException, ServletException
            {
            doGet(request, response);
            }
            }

test2.java
在其中的另一台web主机上建立，用来接收test发送的数据对象，并对其进行处理后返回到test。

程序中涉及的部分API的说明
java.net.URL
URL类表示了一个统一资源路径。这样的资源可能是一个文件或目录，也可能是更为复杂的诸如数据库的查询或是搜索引擎。
在我们的程序中使用了URL的一种构造函数：
URL(String spec)
直接使用字符串作为构造函数的参数，这实际上是URL的众多构造函数中最为简单的一种。
此外，我们还用到了URL的openConnection()方法：
public URLConnection openConnection()
throws IOException
该方法返回了一个URLConnection对象。每次调用该方法时会开启一个到指定URL的新的连接。
这里需要注意的是，调用该方法的结果是建立了一个连接，这与通常的页面跳转完全是两回事。在更多的情况下，这里仅仅是建立了一个连接的通路，而并没有实现任何其它的操作。
java.net.URLConnection
这是一个抽象类，是所有反映application和一个URL之前的通信的类的超类。这个类的实例可以用来对一个URL表示的资源进行读写。
在我们的程序中我们使用了这个类的如下方法：
getInputStream
public InputStream getInputStream()
throws IOException
返回从这个连接读取的一个输入流
getOutputStream
public OutputStream getOutputStream()
throws IOException
返回一个用于写入这个连接的输出流
setDoOutput
public void setDoOutput(boolean dooutput)
设置该连接是否可以写入
setUseCaches
public void setUseCaches(boolean usecaches)
设置该连接是否使用cache
java.io.OutputStream
这是一个抽象类，是所有反映一个二进制输出流的类的超类。一个这样的输出流可以对二进制数据进行输出或发送。
java.io.ObjectOutputStream
该类用来向一个OutputStream写入java的对象。这个对象可以使用ObjectInputStream进行读取或再造。
只有实现java.io.Serializable接口的对象可以写入该数据流中。
在我们的程序中还使用了该类的writeObject()方法：
public final void writeObject(Object obj)
throws IOException
将指定的对象写入ObjectOutputStream。
java.io.InputStream
这是一个抽象类，是所有反映一个二进制输入流的类的超类。
java.io.ObjectInputStream
一个ObjectInputStream对一个使用ObjectOutputStream写入的对象进行解析。
在我们的程序中使用了该类的readObject()方法：
public final Object readObject()
throws OptionalDataException,
ClassNotFoundException,
IOException
从一个ObjectInputStream中读取一个对象。

程序执行的结果
如果一切正常，访问test.Test你应该可以看到这样的结果：
yzysynew
new
yzysyold
new
其中yzysynew，new是对象原来的内容，而yzysyold，new所反映的那个对象已经是传送到test2后经test2处理过的了。

冰河快狼 2008-03-13 15:53 发表评论

Servlet 监听器应用（转）

冰河快狼 — Mon, 03 Dec 2007 08:51:00 GMT

监听器概述
  1.Listener是Servlet的监听器
  2.可以监听客户端的请求、服务端的操作等。
  3.通过监听器，可以自动激发一些操作，如监听在线用户数量,当增加一个HttpSession时，给在线人数加1。
  4.编写监听器需要实现相应的接口
  5.编写完成后在web.xml文件中配置一下,就可以起作用了
  6.可以在不修改现有系统基础上,增加web应用程序生命周期事件的跟踪

常用的监听接口

  1.ServletContextAttributeListener
  监听对ServletContext属性的操作，比如增加/删除/修改
  2.ServletContextListener
  监听ServletContext,当创建ServletContext时，激发contextInitialized(ServletContextEvent sce)方法；当销毁ServletContext时，激发contextDestroyed(ServletContextEvent sce)方法。
  3.HttpSessionListener
  监听HttpSession的操作。当创建一个Session时，激发session Created(SessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。
  4.HttpSessionAttributeListener
  监听HttpSession中的属性的操作。当在Session增加一个属性时，激发attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。

使用范例：

由监听器管理共享数据库连接

生命周期事件的一个实际应用由context监听器管理共享数据库连接。在web.xml中如下定义监听器：

XXX.MyConnectionManager

Øserver创建监听器的实例,接受事件并自动判断实现监听器接口的类型。要记住的是由于监听器是配置在部署描述符web.xml中，所以不需要改变任何代码就可以添加新的监听器。

public class MyConnectionManager implements ServletContextListener{
  public void contextInitialized(ServletContextEvent e) {
        Connection con = // create connection
        e.getServletContext().setAttribute("con", con);
    }
   public void contextDestroyed(ServletContextEvent e) {
        Connection con = (Connection) e.getServletContext().getAttribute("con");
        try {
          con.close();
        }
       catch (SQLException ignored) { } // close connection
    }
}
  监听器保证每新生成一个servlet context都会有一个可用的数据库连接,并且所有的连接对会在context关闭的时候随之关闭。

计算在线用户数量的Linstener

(1)
Package xxx;

public class OnlineCounter {
   private static long online = 0;
   public static long getOnline(){
      return online;
    }
    public static void raise(){
       online++;
    }
    public static void reduce(){
       online--;
   }
}

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class OnlineCounterListener implements HttpSessionListener{
    public void sessionCreated(HttpSessionEvent hse) {
        OnlineCounter.raise();
    }
   public void sessionDestroyed(HttpSessionEvent hse){
        OnlineCounter.reduce();
    }
}

在需要显示在线人数的JSP中可是使用
目前在线人数：
<%@ page import=“xxx.OnlineCounter" %>
<%=OnlineCounter.getOnline()%>

退出会话(可以给用户提供一个注销按钮)：



exit.jsp: <%session.invalidate() ;%>

在web.xml中加入:

servletlistener111111.SecondListener

怎么样，就是这么简单，不用对现有代码做任何的修改。

冰河快狼 2007-12-03 16:51 发表评论

B/S系统权限控制的一种简单方法 (转)

冰河快狼 — Fri, 31 Aug 2007 08:37:00 GMT

看了网上一些关于权限控制的帖子，越看越迷糊，什么用AOP(Aspect Oriented Programming,面向方面编程)，用容器，RBAC(基于角色的访问控制方法),SSO,Jive的Proxy模式等等等等，且又是role又是group，真是头都大了，先写个简单的实现方法，以后再研究高深的。
此方法不依赖容器框架，适用于小系统(主要JSP页面要少于100,因为是硬编码到JSP)，适用于要精确控制页面field的情况较多的系统。
(插句话：要分清权限控制与业务逻辑，业务逻辑就是情况由系统运行时的某些条件决定，如学生管理系统中，某一学生进入系统，只能看自己的记录，因为可看的记录是由学号来决定的，所以这是业务逻辑，而又如学生不能看老师的记录，这是有学生的身份来决定的，所以这是权限控制。)
好了，进入正题！
建表：
user(user信息： userID userPassword 等)
role(role描述：roleID roleDesc)
permission(permission描述：permissionID permissionDesc)
user-role(user role对应关系表：userID roleID)
role-permission(role permission对应关系表：roleID permissionID)
user-permission(user permission对应关系表：userID permissionID)

重要申明：

1 此处role没有继承关系,只是permission的集合
2 user-permission表只是为了方便，其数据是根据user-role role-permission两表得来，只有在user-role role-permission两表有更新的时候更新此表，并不能单独赋予user某个permission,只能赋予user一个或多个role。
3 permission的分配，这是一个难点，很多比较复杂的权限控制系统也是因为这个才发展出来，此处把它尽量想简单，不考虑业务逻辑，以页面为视角，分两层，首先是需要控制的jsp页面，然后是需要控制的页面field(包括link,text,textbox,button等等)，field这一层还有privilege之分(R和W，即可读和可写)
基本思路：进入JSP页面时，检查用户信息，查到用户有此permission就包含此代码，如果没有此permission就不包含此代码，此功能由Tag来完成(不会写Tag？不要紧，抄！)。看代码吧！
1 建表(如上)
2 建两个class(bean) (UserProfile是用户基本信息 UserPermission是permission )
UserProfile.java:
package com.××.××.××;
import java.util.Collection;

public class UserProfile {
private String userId;
private String userType;
private String companyNo;
private String companyName;
private String companyType;
private Collection userPermissions;

public String getUserId() {
    return userId;
}
public void setUserId(String userId) {
    this.userId = userId;
}
public String getUserType() {
    return userType;
}
public void setUserType(String userType) {
    this.userType = userType;
}
public String getCompanyNo() {
    return companyNo;
}
public void setCompanyNo(String companyNo) {
    this.companyNo = companyNo;
}
public String getCompanyName() {
    return companyName;
}
public void setCompanyName(String companyName) {
    this.companyName = companyName;
}
public String getCompanyType() {
    return companyType;
}
public void setCompanyType(String companyType) {
    this.companyType = companyType;
}
public Collection getUserPermissions() {
    return userPermissions;
}
public void setUserPermissions(Collection userPermissions) {
    this.userPermissions = userPermissions;
}
}

UserPermission.java:
package com.××.××.××;

public class UserPermission {
private int permissionId;
private String privilege;
public int getPermissionId() {
    return permissionId;
}
public void setPermissionId(int permissionId) {
    this.permissionId = permissionId;
}
public String getPrivilege() {
    return privilege;
}
public void setPrivilege(String privilege) {
    this.privilege = privilege;
}
}

3 加两个Tag(Page与Field)：
SecurityTagForPage.java：
package com.**.**.taglib;
import java.util.*;

public class SecurityTagForPage extends TagSupport
{

private int permissionID;

public int doEndTag() throws JspException
{
HttpSession session = pageContext.getSession();
//登陆时把该user的userProfile放到session里
UserProfile userProfile = (UserProfile)session.getAttribute("userProfile");
Collection collection= userProfile.getUserPermissions();
Iterator it = collection.iterator() ;
while(it.hasNext())
{
      UserPermission userPermission = (UserPermission)it.next();
       if ((permissionID == userPermission.getPermissionId()))
         {
           return EVAL_PAGE;
         }
    }
    return SKIP_PAGE;
}

public int getPermissionID()
{
return permissionID;
}
public void setPermissionID(int permissionID)
{
this.permissionID = permissionID;
}
}

SecurityTagForField：
public class SecurityTagForField extends TagSupport
{
private int permissionID;
private String privilege;

public int doStartTag() throws JspException
{
HttpSession session = pageContext.getSession();
UserProfile userProfile = (UserProfile)session.getAttribute("userProfile");

    Collection collection= userProfile.getUserPermissions();
    Iterator it = collection.iterator() ;
    while(it.hasNext())
    {
      UserPermission userPermission = (UserPermission)it.next();
    if (privilege ==null)
       {

if ( (permissionID == userPermission.getPermissionId()))
         {
           return EVAL_BODY_INCLUDE;
         }
       }
      else
      {
          if ((permissionID == userPermission.getPermissionId())
              &&(privilege.equals(userPermission.getPrivilege())))
          {
            return EVAL_BODY_INCLUDE;
          }
      }
    }
    return SKIP_BODY;
}

public int getPermissionID()
{
    return permissionID;
}
public void setPermissionID(int permissionID)
{
    this.permissionID = permissionID;
}
public String getPrivilege()
{
    return privilege;
}
public void setPrivilege(String privilege)
{
    this.privilege = privilege;
}
}
4 在web-inf目录下建个securityTag.tld文件，内容如下：(改一下class的目录)

"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

1.0
1.1
security

    access control!

  securityForField
  com.companyname.prjname.taglib.SecurityTagForField

                permissionID
                true


                  privilege

  securityForPage
  com.companyname.prjname.taglib.SecurityTagForPage

                permissionID
                true

5 修改需要控制的jsp
在jsp页面这样写：
<%@ taglib uri="/WEB-INF/securityTag.tld" prefix="security" %>
<%@ page import="com.hp.elog2.util.Util" %>

.......

......
这样就大功告成了，建议在所有jsp页面完成后再做权限控制这一块(添加Tag)，主要都是些Copy＋C和Copy＋V的工作。
此方法最大的问题就是hardcode太多，但结构简单，思路清晰，适用范围广。
复杂的方法希望同道之士于我联系leon_sandy@tom.com，共同研究！

冰河快狼 2007-08-31 16:37 发表评论

Tomcat5.0-5.5连接池配置指南（转）

冰河快狼 — Sat, 16 Dec 2006 03:08:00 GMT

本文以目前最流行的MySQL为例，讲解通过Tomcat连接池连接MySQL数据库的基本步骤，如果你了解MySQL可跳过第一步。

　　在进行Tomcat连接池配置前，先解压缩mysql-connector-java-xxx.zip，将其中的mysql-connector-java-3.x.x-xxx.jar取出，置于<%TOMCAT_HOME%>\common\lib中。

　　接下来，让我们一起进入精彩的Tomcat配置之旅。

一.新建用户及数据库

操作步骤如下：

C:\Documents and Settings\Administrator>d:

D:\>cd mysql\bin

D:\MySQL\bin>mysql -u root -p
Enter password: *******
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 51 to server version: 4.1.12a-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> GRANT ALL PRIVILEGES ON jcc.* TO jcc@localhost IDENTIFIED BY 'jsp.com.cn'
WITH GRANT OPTION;
Query OK, 0 rows affected (0.01 sec)

mysql> USE mysql;
Database changed
mysql> SELECT Host,User,Password FROM user;
+-----------+------+-------------------------------------------+
| Host      | User | Password                                  |
+-----------+------+-------------------------------------------+
| localhost | root | *60D5B730382EC2170CA366DE181767E4C5343DE8 |
| %         | jsp  | *C22AB0FD8A289C7D337C9998B63B8EA8335E5F35 |
| localhost | jcc  | *C22AB0FD8A289C7D337C9998B63B8EA8335E5F35 |
+-----------+------+-------------------------------------------+
3 rows in set (0.01 sec)

mysql> exit
Bye

D:\MySQL\bin>mysql -u jcc -p
Enter password: **********
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 57 to server version: 4.1.12a-nt

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> CREATE DATABASE jcc;
Query OK, 1 row affected (0.02 sec)

mysql> USE jcc;
Database changed
mysql> CREATE TABLE user(
    ->   id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    ->   name VARCHAR(8) NOT NULL
    -> );
Query OK, 0 rows affected (0.08 sec)

mysql> INSERT INTO user (name) VALUES ('Corebit');
Query OK, 1 row affected (0.03 sec)

mysql> INSERT INTO user (name) VALUES ('Ivan');
Query OK, 1 row affected (0.03 sec)

mysql> SELECT * FROM user;
+----+---------+
| id | name    |
+----+---------+
|  1 | Corebit |
|  2 | Ivan    |
+----+---------+
2 rows in set (0.00 sec)

mysql>

二.配置Tomcat连接池

Tomcat5.0进行如下配置：

在<%TOMCAT_HOME%>\conf\server.xml的...之间加入以下代码：

        debug="5" reloadable="true" crossContext="true">

               prefix="localhost_DBTest_log." suffix=".txt"
             timestamp="true"/>

                 auth="Container"
               type="javax.sql.DataSource"/>



      factory
      org.apache.commons.dbcp.BasicDataSourceFactory



      maxActive
      100



      maxIdle
      30



      maxWait
      10000



     username
     jcc


     password
     jsp.com.cn



       driverClassName
       com.mysql.jdbc.Driver



      url
      jdbc:mysql://localhost/jcc



Tomcat5.5进行如下配置：

在<%TOMCAT_HOME%>\conf\server.xml的...之间加入以下代码：

        debug="5" reloadable="true" crossContext="true">

                 maxActive="100" maxIdle="30" maxWait="10000"
               username="jcc" password="jsp.com.cn" driverClassName="com.mysql.jdbc.Driver"
               url="jdbc:mysql://localhost/jcc"/>

三.在<%wwwroot%>/下，新建MySQL数据库连接文件Select.jsp

　　Select.jsp源码如下：

<%@page contentType="text/html;charset=gb2312"%>
<%@page import="java.sql.*"%>
<%@page import="javax.sql.DataSource"%>
<%@page import="javax.naming.*"%>

<%
try{
  Context initCtx=new InitialContext();
  DataSource db = (DataSource)initCtx.lookup("java:comp/env/jdbc/JCC");
  Connection conn = db.getConnection();
  Statement stmt = conn.createStatement();
  ResultSet rs = stmt.executeQuery("SELECT * FROM user");
  out.println("User-list"+"
");
  while(rs.next()){
    out.print(rs.getString(1)+" ");
    out.print(rs.getString(2)+"
");
  }
  rs.close();
  stmt.close();
  conn.close();
}
catch(Exception e){
  out.print(e);
}
%>

四.运行http://localhost/Select.jsp，显示结果如下：

User-list
1 Corebit
2 Ivan

　　则表示数据库连接成功！恭喜！恭喜！

　　否则请检查数据库连接器版本，出错可能性比较高！

　　＊注：

　　Tomcat连接池中，部分参数说明如下：

　　maxActive="100"　　

　　maxIdle="30"

　　maxWait="10000"

    jdbc:mysql://localhost/jcc

    PS：如果最大数据库活跃连接数过大，可想而知，内存占用量是非常惊人的！如果空闲连接数过大，则资源利用率低，连接池长期未释放，可导致连接池结点异常。所以选好maxActive和maxIdle是连接池性能的关键因素，当然这取决于服务器环境。

　　＊附：

　　连接池运作原理：

　　在实际应用开发中，特别是在WEB应用系统中，如果JSP、Servlet或EJB使用JDBC直接访问数据库中的数据，每一次数据访问请求都必须经历建立数据库连接、打开数据库、存取数据和关闭数据库连接等步骤，而连接并打开数据库是一件既消耗资源又费时的工作，如果频繁发生这种数据库操作，系统的性能必然会急剧下降，甚至会导致系统崩溃。数据库连接池技术是解决这个问题最常用的方法，在许多应用程序服务器（例如：Weblogic,WebSphere,JBoss）中，基本都提供了这项技术，无需自己编程，但是，深入了解这项技术是非常必要的。

　　数据库连接池技术的思想非常简单，将数据库连接作为对象存储在一个Vector对象中，一旦数据库连接建立后，不同的数据库访问请求就可以共享这些连接，这样，通过复用这些已经建立的数据库连接，可以克服上述缺点，极大地节省系统资源和时间。

　　数据库连接池的主要操作如下：

　　（1）建立数据库连接池对象（服务器启动）。

　　（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。

　　（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。

　　（4）存取数据库。

　　（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。

　　（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）。

　　希望本文能对你使用Tomcat连接池连接MySQL数据库有所帮助！

参考文献：
http://jakarta.apache.org/tomcat/tomcat-5.0-doc/jndi-datasource-examples-howto.html
http://jakarta.apache.org/tomcat/tomcat-5.5-doc/jndi-datasource-examples-howto.html

冰河快狼 2006-12-16 11:08 发表评论