准备好了吗？让我们开始下一步

第一步：写一个简单的EJB。写EJB最好用的还是JBuilder，毕竟够傻瓜化。当然作为专业人士，eclipse搭配MyEclipse是最佳选择，不过作为初学者，建议采用JBuilder。以下是本文测试所用到的EJB。

remote接口：

package testhello;

import javax.ejb.EJBObject;

public interface SayHello extends EJBObject {
    public String sayHello(String name) throws java.rmi.RemoteException;
}

home接口：

package testhello;

import javax.ejb.EJBHome;
import javax.ejb.CreateException;
import java.rmi.RemoteException;

public interface SayHelloHome extends EJBHome {
    public SayHello create() throws CreateException, RemoteException;
}

bean类：

package testhello;

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
import javax.ejb.CreateException;

public class SayHelloBean implements SessionBean {
    SessionContext sessionContext;
    public void ejbCreate() throws CreateException {
    }

    public void ejbRemove() {
    }

    public void ejbActivate() {
    }

    public void ejbPassivate() {
    }

    public void setSessionContext(SessionContext sessionContext) {
        this.sessionContext = sessionContext;
    }

    public String  sayHello(String name) {
        return "Hello "+name;
    }
}

如果你是采用上面两种工具来写的话，配置文件就不必考虑了

第二步：利用JBuilder或eclipse将这个EJB工程编译并打包，会得到一个jar(如果你的工程名叫testhello，那么这个jar文件就是testhello.jar)文件。如果你的EJB容器（weblogic或JBoss）是在本机上，那么在JBuilder或eclipse中就可以直接鼠标右击EJB工程，来部署EJB。如果需要部署到远程服务器上，只需要通过EJB容器的控制台将testhello.jar上传到远程端，然后在EJB Modler里面按提示部署好EJB。最后，别忘了在JNDI Tree里面察看你的EJB工程的JNDI名，本例的JNDI名叫SayHello

第三步：将remote接口和home接口打包成jar文件，copy到你要远程调用EJB的struts工程下的lib目录（例如：helloapp ->WEB-INF ->lib）

第四步：将weblogic的weblogic.jar（在weblogic的安装目录－>weblogic81－>server－>lib文件夹中）copy到tomcat安装目录下的－>shared－>lib文件夹中，其实这里我们需要用到的只是weblogic.jar里的几个class文件而已，不过对于初学者而言，先不必去深究到底只需要那几个class。

第五步：编写一个简单的struts工程（其实这些都可以用工具生成），一下是调用EJB的HelloAction的源代码(特别要注意的是，记得要将之前第三步生成的jar包导入编辑器中，否则下面的代码编译通不过。如果你不知道导入jar包，就把那个jar包多copy一份到你的jdk安装目录 -> jre-> lib-> ext文件夹下)

package logging.actions;
import logging.Constants;

import java.util.*;
import javax.servlet.ServletException;
import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;
import org.apache.struts.util.MessageResources;
import org.apache.struts.validator.DynaValidatorForm;

public final class HelloAction extends Action{
 
 public ActionForward execute(ActionMapping mapping,
         ActionForm form,
         HttpServletRequest request,
         HttpServletResponse response)
 throws Exception{

        InitialContext ctx=this.getInitialContext();

  //查找JNDI名为SayHello的EJB组件
        Object obj=ctx.lookup("SayHello");

  //获得远程EJB组件的home接口的引用
        testhello.SayHelloHome home=(testhello.SayHelloHome)PortableRemoteObject.narrow(obj,testhello.SayHelloHome.class);

  //获得远程EJB组件的remote接口的引用
        testhello.SayHello hello=home.create();
        
        String name="飘然随风";
        String sayString=hello.sayHello(name);
        
        request.setAttribute("userName",name);
        request.setAttribute("passWord",sayString);
        request.removeAttribute(mapping.getAttribute());
      
  return mapping.findForward("loginSuccess");
 }
 

/*以下方法是作用是：通过传递环境属性选择JNDI驱动和服务器的网络位置，
  并连接到连接到JNDI树。
  这是采用weblogic做EJB容器时，远程调用EJB的固定初始化模式，初学者可以死记下来
*/
 private  InitialContext getInitialContext() throws Exception {
  //EJB容器的地址
     String url = "t3://image:7001";
     String user = null;
     String password = null;
     Properties properties;
  
        properties = new Properties();
        properties.put(Context.INITIAL_CONTEXT_FACTORY,
                       "weblogic.jndi.WLInitialContextFactory");
        properties.put(Context.PROVIDER_URL, url);
        if (user != null) {
            properties.put(Context.SECURITY_PRINCIPAL, user);
            properties.put(Context.SECURITY_CREDENTIALS,
                           password == null ? "" : password);
        }
        return new javax.naming.InitialContext(properties);
 }
}

第六步：如果你严格按照上面的步骤做了，那么剩下的就是同时启动weblogic和tomcat来测试了。

我使用的filter是Craig McClanahan写的，这位仁兄大名鼎鼎，他是Struts框架的主要体系设计师和开发者，Tomcat4的主设计师和Java Web Services Developer Pack实现包的主设计师，领导着Sun的JavaServer Faces规范开发，同时也是Java EE平台的Web Layer Archiecture。filter的代码附在文后。

web.xml中的配置如下：

<!-- GBK Encodinbg Filter definition -->
<filter>
<filter-name>Set Character Encoding</filter-name>
<filter-class>filters.SetCharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GBK</param-value>
</init-param>
</filter>

<!-- GBK Encoding Filter mapping -->
<filter-mapping>
<filter-name>Set Character Encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

　　1.编写主接口程序
　　在文本编辑器中编辑HelloHome.java文件，并保存在C:\work\hello目录下，其代码为：
　　//本接口需要引入的类或接口
　　import java.rmi.RemoteException;
　　import javax.ejb.CreateException;
　　import javax.ejb.EJBHome;
　　//定义主接口，必须继承EJBHome
　　public interface HelloHome extends EJBHome {
　  //定义EJB创建方法
　　　Hello create() throws CreateException, RemoteException;
　　}
　　2.编写远程接口程序
　　在文本编辑器中编辑Hello.java文件，并保存在C:\work\hello目录下。Hello.java文件的代码为：
　　//本接口需要引入的类或接口
　　import javax.ejb.EJBObject;
　　import java.rmi.RemoteException;
//定义远程接口，必须继承EJBObject
　　public interface Hello extends EJBObject {
　　　//定义业务逻辑方法
　　　public String sayHello()
　　　throws RemoteException;
　　}
3.编写Bean类实现程序
　　在文件编辑器中编辑HelloBean.java文件，并保存在C:\work\hello目录下。HellloBean.java文件的代码为：
　　//本类需要引入的类或接口
　　import javax.ejb.CreateException;
　　import javax.ejb.SessionBean;
　　import javax.ejb.SessionContext;
　　//实现业务逻辑，必须实现SessionBean接口
　　public class HelloBean implements SessionBean {
　　　//这是个会话EJB，声明会话上下文
　　　private SessionContext ctx;
　　　//声明字符串
　　　private String words;
　　　//接口SessionBean中定义的方法，必须实现
　　　public void setSessionContext(SessionContext ctx) {
　　　　this.ctx = ctx;
　　　}
　　　//接口SessionBean中定义的方法，必须实现
　　　public void ejbActivate() {
　　　}
　　　//接口SessionBean中定义的方法，必须实现
　　　public void ejbPassivate() {
　　　}
　　　//接口SessionBean中定义的方法，必须实现
　　　public void ejbRemove() {
　　　}
　　　//和主接口定义对应的方法，必须实现
　　　public void ejbCreate() throws CreateException {
　　　　words = "Hello World";
　　　}
　　　//供客户端调用的业务逻辑方法，这里只简单的打印字符串，并把字符串返回到客户端
　　　public String sayHello()
　　　{
　　　　System.out.println("I am in an EJB of Server ."+words);
　　　　return words;
　　　}　　}
（3） EJB代码编译
　　首先打开命令窗口，进入C:\work\hello目录，运行环境变量脚本程序：
　　　c:\work\hello>c:\work\setEnv
　　建立build目录：
　　　c:\work\hello>md build
　　执行编译命令：
　　　c:\work\hello>java -d build Hello.java HelloHome.java HelloBean.java
　　其中：-d build 表示编译生成的class文件放在build目录中。
（4）EJB部署文件编写
　　部署文件是EJB的重要组成部分。简单地说，部署文件就是EJB的说明文件，这个文件由服务器容器使用，服务器根据部署文件的说明来管理EJB。
　　EJB部署文件是标准的XML文件，必须遵守XML的语法规则。此外，还要遵守相关的DTD规则。
　　部署文件到少有两个文件ejb-jar.xml和weblogic-ejb-jar.xml。前者为EJB自身的一些特征，如名称、组成等：后者是和EJB部署相关的描述。
　　编写部署文件：
　　(1)在文件编辑器中编辑ejb-jar.xml文件，并保存在C:\work\hello目录下。ejb-jar.xml文件的内容为：
<?xml version="1.0"?>
<!DOCTYPE ejb-jar PUBLIC '-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN' 'http://java.sun.com/j2ee/dtds/ejb-jar_1_1.dtd'>
<!--EJB说明文件-->
<ejb-jar>
<small-icon>images/green-cube.gif</small-icon>
<enterprise-beans>
<!--定义会话EJB-->
<session>
<small-icon>images/orange-cube.gif</small-icon>
<!--定义会话EJB名-->
<ejb-name>MyFirstEJB</ejb-name>
<!--定义会话EJB主接口名-->
<home>HelloHome</home>
<!--定义会话EJB远程接口名-->
<remote>Hello</remote>
<!--定义会话EJB实现类名-->
<ejb-class>HelloBean</ejb-class>
<!--定义会话EJB类型-->
<session-type>Stateless</session-type>
<transaction-type>Container</transaction-type>
</session>
</enterprise-beans>
<!--定义会话EJB装配描述-->
<assembly-descriptor>
<container-transaction>
<method>
<ejb-name>MyFirstEJB</ejb-name>
<method-intf>Remote</method-intf>
<method-name>*</method-name>
</method>
<trans-attribute>Required</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>
　　(2)在文件编辑器中编辑weblogic-ejb-jar.xml文件，并保存在C:\work\hello目录下。weblogic-ejb-jar.xml文件的内容为：
<?xml version="1.0"?>
<!DOCTYPE weblogic-ejb-jar PUBLIC '-//BEA Systems, Inc.//DTD WebLogic 5.1.0 EJB//EN' 'http://www.bea.com/servers/wls510/dtd/weblogic-ejb-jar.dtd'>
<!--EJB部署说明文件-->
<weblogic-ejb-jar>
<weblogic-enterprise-bean>
<!--EJB名-->
<ejb-name>MyFirstEJB</ejb-name>
<!--定义EJB最大缓冲池-->
<caching-descriptor>
<max-beans-in-free-pool>100</max-beans-in-free-pool>
</caching-descriptor>
<!--定义EJB jndi名称-->
<jndi-name>HelloHome</jndi-name>
</weblogic-enterprise-bean>
</weblogic-ejb-jar>
（5） 打包
　　把上面开发的所有文件打成jar文件包。这些文件包括一三个类文件：Hello.class、HelloHome.class、HelloBean.class和部署文件：ejb-jar.xml,weblogic-ejb-jar.xml。打包时，文件放置的位置是严格要求的。具体为：*.class文件放在当前目录(即C:\work\hello\build目录下)，部署文件必须入在下一级目录Meta-inf中(即C:\work\hello\build\Meta-inf目录下)。如果EJB包含图像文件，则图像文件必须在build目录的下一级目录images中(即C:\work\hello\build\images目录下)。
　　具体操作步骤为：
　　(1)在build目录中创建Meta-inf目录，当前路径为C:\work\hello，执行：
　　　c:\work\hello>md build\Meta-inf
　　(2)把部署文件拷贝到hello\Meta-inf目录下：
　　　c:\work\hello>copy *.xml build\Meta-inf
　　(3)执行：
　　　c:\work\hello>md build\images
　　　c:\work\hello>copy *.gif build\images
　　当然，本例中没有使用图像文件，所以可以免去此步骤。
　　(4)用jar命令在build目录下打包。当前路径是c:\work\hello，运行：
　　　c:\work\hello>cd build
　　　c:\work\hello\bulid>jar cv0f std_myfirstejb_hello.jar META-INF *.class images
　　　c:\work\hello\build>cd..
　　其中：jar是Jdk中的打包命令：cv0f是命令参数；std_myfirstejb_hello.jar是生成的文件名，由用户指定。
　　命令执行完后，在目录build中应该生成文件std_myfirstejb_hello.jar。
　　至此，打包完成。
（6）编译生成窗口代码
　　Weblogic Server提供了编译生成容器代码的工具，它是一个java程序weblogic.ejbc。在命令行窗口中执行：
　　c:\work\hello>java weblogic.ejbc -compiler javac build\std_myfirstejb_hello.jar build\myfirstejb_hello.jar
　　可以看出ejbc把std_myfirstejb_hello.jar文件编译成myfirstejb_hello.jar，它包括了Weblogic Server平台可以识别的ejb容器代码。
　　如果运行成功，则在build目录下产生myfirstejb_hello.jar文件。

(1)安装破解Weblogic 8.3.1后( www.9iv.com )，运行Configuration Wizard；

(2)选择Create a new Weblogic configuraion；

(3)Select a Configuration Template中选择Basic Weblogic Server Domain；

(4)Chose Express or Custom Configuration中我选择的是Express(如果对配置很熟悉还是选择Custom比较好些)；

(5)在Configure Administrative Username and Password中设置用户名和密码；

(6)在Configure Server Start Mode and Java SDK中我选择了Development Mode，在JDK中选择了BEA默认安装的Sun JDK 1.4.2_04；

(7)在下一步部署中输入需要的Congfiguration Name就可以Create了。

第二步在MyEclipse配置Weblogic：

(1)选择菜单Window->Preferences->MyEclipse->Application Servers->Weblogic 8，配置项目如下：

BEA home directory: 选择Bea的安装目录

Weblogic installation directory:现在BEA下面的weblogic81目录

Admin username:输入上面在配置过程中设的用户名

Admin password:输入刚才设的密码

Execution domain root:选择BEA下user_projects\domains目录下上面第一步创建的目录

Execution domain name:输入上面那个目录的名称

Execution server name:输入上一步的那个Congfiguration Name

Hostname:PortNumber:输入IP地址和监听的端口

Security policy file:输入BEA安装目录下的\weblogic81\server\lib\weblogic.policy

(2)在Weblogic 8下面配置JDK，在WLS JDK name那里选择新建，弹出的对话框中选择BEA下面的JDK安装路径，输入一个名字确定就可以；在Optional Java VM arguments对话框里面输入-ms64m -mx64m -Djava.library.path="D:/BEA/weblogic81/server/bin" -Dweblogic.management.discover=false -Dweblogic.ProductionModeEnabled=false

(3在Weblogic 8下面配置Paths，加入BEA安装路径下/weblogic81/server/lib中的webservices.jar和weblogic.jar两个包。如果需要其他的包，也在这里加入。

简单的说log4j就是帮助开发人员进行日志输出管理的API类库。它最重要的特点就

可以 配置文件灵活的设置 日志信息的优先级、日志信息的输出目的地以及日志信息的输出格式。

Log4j除了可以记录程序运行日志信息外还有一重要的功能就是用来 显示调试信息。程序员经常会遇到脱离java ide环境调试程序的情况，这时大多数人会选择使用System.out.println语句输出某个变量值的方法进行调试。这样会带来一个非常麻烦的问题：一旦哪天程序员决定不要显示这些System.out.println的东西了就只能一行行的把这些垃圾语句注释掉。若哪天又需调试变量值，则只能再一行行去掉这些注释恢复System.out.println语句。使用log4j可以很好的处理类似情况。

log4j使用方法

下面介绍的是log4j一些理论方面的知识，读者觉得枯燥的话可以跳过本节直接阅读第三节实例部分。

　　1、定义配置文件

　  首先使用配置文件将使我们的应用程序更加灵活配置log日志输出方式包括输出优先级、输出目的地、输出格式。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件log4j.properties（键=值）。下面将介绍使用log4j.properties文件作为配置文件的方法：

　　 ① 配置根Logger，其语法为：0

　　log4j.rootLogger = [ level ] , appenderName, appenderName, …

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指定日志信息输出到哪个地方。可同时指定多个输出目的地。

　　 ② 配置日志信息输出目的地Appender，其语法为：

　　 log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.option = valueN

　　其中， Log4j提供的appender有以下几种：
　　org.apache.log4j.ConsoleAppender（控制台），
　　org.apache.log4j.FileAppender（文件），
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　 ③ 配置日志信息的格式（布局），其语法为：

　　 log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

　　其中， Log4j提供的layout有以下几种：
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　 %p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　2、在代码中使用Log4j

　　 ① 得到记录器

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

　　static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

　　 ② 读取配置文件

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。

例：PropertyConfigurator.configure (".\\src\\log4j.properties")
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　 ③ 插入记录信息（格式化日志信息）

　　当上两个必要步骤执行完毕，就可轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

　　 Logger.debug ( Object message ) ;
　　Logger.info ( Object message ) ;
　　Logger.warn ( Object message ) ;
　　Logger.error ( Object message ) ;

log4j范例程序

下面将使用一个最简单的范例程序来进一步说明log4j的使用方法。程序代码如下：

import org.apache.log4j.*;

public class LogTest {

    static Logger logger = Logger.getLogger(LogTest.class.getName());

    public static void main(String[] args) {

        PropertyConfigurator.configure ( “.\\src\ log4j.properties ”) ；

logger.debug( "Debug ..." );

        logger.info( "Info ..." );

        logger.warn( "Warn ..." );

        logger.error( "Error ..." );

    }

}

程序说明：

① static Logger logger = Logger.getLogger(LogTest.class.getName()); 就是创建一个属于 LogTest 类的 Logger 对象，创建时要告知 Logger 你当前的 Class 是什么。

② PropertyConfigurator.configure ( “ log4j.properties ”) 就是说使用当前工程目录下的 src 文件夹中的 log4j.properties 文件作为配置文件。若将 log4j.properties 放在工程根目录下也可不写此句，程序会自动找到配置文件。

③ logger.debug 就是输出 debug 的信息， logger.info 就是输出提示信息， logger.warn 就是显示警告信息， logger.error 就是显示错误信息。

下面是配置文件 log4j.properties 的内容：

log4j.rootCategory=DEBUG, stdout ， R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=log.txt

log4j.appender.R.MaxFileSize=100KB

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%d { yyyy MMM dd HH:mm:ss } %-5p %c - %m%n

程序说明：

① log4j.rootCategory=DEBUG, stdout ， R

就是说我要显示所有优先权等於和高于 Debug的信息。
"stdout"， ”R” 表示我定义了两个输出端 ( 随便什么名字都好 ) 。

② 下面的三行说 stdout 输出端其实是标准输出 Console ，也就是屏幕。输出的格式是 Pattern Layout 。转换方式是 %5p (%F:%L) - %m%n ，即前五格用来显示优先权，再显示当前的文件名，加当前的行数。最后是 logger.debug() 或 logger.info() 或 logger.warn() 或 logger.error() 里的信息。 %n 表示回车空行。

③ 再加上下面六行则 log 信息不光显示在屏幕上，而且将被保存在一个叫 "log.txt" 的文件里，文件最大为 100KB 。如果文件大小超过 100KB ，文件会被备份成 "log.txt.1" ，新的 "log.txt" 继续记录 log 信息。

接下来我们可以改变 log4j.properties ，而不需重新编译就可以控制 log 信息是否显示、 log 信息的输出端类型、输出方式、输出格式，等等。举例如下：

① 在 log4j.properties 文件里把 "log4j.rootCategory=DEBUG,stdout,R" 改写成 "log4j.rootCategory=OFF, stdout,R" ，这样所有的 log信息都不会显示了；解决了本文开始提出的问题。
② 在 log4j.properties 文件里把 "log4j.rootCategory=DEBUG,stdout,R" 改写成 "log4j.rootCategory=INFO, stdout,R" ，这样只显示 INFO, WARN, ERROR 的 log 信息，而 DEBUG 信息不会被显示；

在web程序中使用log4j注意问题

1、    由于jsp或servlet在执行状态时没有当前路径概念，所有使用 PropertyConfigurator.configure （ String ）语句找 log4j.properties 文件时要给出相对于当前 jsp 或 servlet 的路径转化成为一个绝对的文件系统路径。方法是使用 servletcontext.getrealpath(string) 语句。例：

//得到当前jsp路径

String prefix =  getServletContext().getRealPath( "/");

//读取 log4j.properties

PropertyConfigurator.configure(prefix+ "\\WEB-INF\\log4j.properties");

2、相应的log4j.properties设置某个属性时也要在程序中设置绝对路径。例：

log4j.appender.R.File属性设置日志文件存放位置。我们可以用读写.properties配置文件的方法进行灵活设置。

Parameters

This component has also the ability to pool PreparedStatements. When enabled a statement pool will be created for each Connection and PreparedStatements created by one of the following methods will be pooled:

• public PreparedStatement prepareStatement(String sql)
• public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)

NOTE - Make sure your connection has some resources left for the other statements.

When allowed you can access the underlying connection using the following construct:

    Connection conn = ds.getConnection();
    Connection dconn = ((DelegatingConnection) conn).getInnermostDelegate();
    ...
    conn.close()

Default is false, it is a potential dangerous operation and misbehaving programs can do harmfull things. (closing the underlying or continue using it when the guarded connection is already closed) Be carefull and only use when you need direct access to driver specific extentions.

NOTE: Do not close the underlying connection, only the original one.

If you have enabled "removeAbandoned" then it is possible that a connection is reclaimed by the pool because it is considered to be abandoned. This mechanism is triggered when (getNumIdle() < 2) and (getNumActive() > getMaxActive() - 3)

For example maxActive=20 and 18 active connections and 1 idle connection would trigger the "removeAbandoned". But only the active connections that aren't used for more then "removeAbandonedTimeout" seconds are removed, default (300 sec). Traversing a resultset doesn't count as being used.

conf/web.xml文件:
<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

需要３个包（别忘了数据库驱动包）

commons-collections-3.1.jar
commons-dbcp-1.2.1.jar
commons-pool-1.2.jar

public ActionForward execute(
        ActionMapping mapping,
        ActionForm form,
        HttpServletRequest request,
        HttpServletResponse response)
        throws Exception
{
        DataSource dataSource;
        Connection cnn;

        try
        {
                dataSource = getDataSource(request);
                cnn = dataSource.getConnection();
                // 数据连接已经建立了，你可以做你想做的事情了
        }
        catch (SQLException e)
        {
                getServlet().log("处理数据库连接", e);
        }
        finally
        {
                // 在finally块里包含这些代码
                // 用以保证连接最后会被关闭
                try
                {
                        cnn.close();
                }
                catch (SQLException e)
                {
                        getServlet().log("关闭数据库连接", e);
                }
        }
}

  注意：如果你使用公共的BasicDataSource，你提供给pingQuery属性的查询语句（如果你设置了话）必须至少要能返回一行记录。

例子：SELECT COUNT(*) FROM VALIDTABLE

你可以把VALIDTABLE替换成你的数据库中包含的任何有效的表。

数据库连接字符串
SQLServer2000:
  driverClassName:com.microsoft.jdbc.sqlserver.SQLServerDriver
  url: jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=databasename
MySql:
   driverClassName:com.mysql.jdbc.Driver
  url: jdbc:mysql://localhost/databasename

［使用多个数据源］

如果你需要在模块（Module）中使用多于一个的数据源，你可以在配置文件的<data-source>元素里包含一个key属性。

<data-source>
        <data-source key="A" type="org.apache.commons.dbcp.BasicDataSource">
                …属性配置略, 同上…
        </data-source>
        <data-source key="B" type="org.apache.commons.dbcp.BasicDataSource">
                …属性配置略, 同上…
        </data-source>
</data-source>

你代码里，你可以通过这些key获得不同的数据源。代码如下：

…
try
{
        dataSourceA = getDataSource(request, "A");
        dataSourceB = getDataSource(request, "B");
…

你可以根据需要为每一个模块设置多个数据源。但同一模块里每个数据源的key属性必须唯一，因为Struts模块系统是以每一个模块为单位管理命名空间的。

常用log4j配置 [转]

常用log4j配置，一般可以采用两种方式，.properties和.xml,下面举两个简单的例子：

一、log4j.properties

### 设置com.unmi域对应的级别INFO,DEBUG,WARN,ERROR和输出地A1，A2 ##
log4j.category.com.unmi=ERROR,A1
log4j.category.com.unmi=INFO,A2

### 一般把上面两行写如下方式，统一控制日志输出,再用log4j.logger设置包独立的输出级别 ##
log4j.rootLogger=DEBUG,A1
log4j.logger.com.unmi.special = ERROR

### 设置输出地A1，为ConsoleAppender(控制台) ##
log4j.appender.A1=org.apache.log4j.ConsoleAppender

### 设置A1的输出布局格式PatterLayout,(可以灵活地指定布局模式）##
log4j.appender.A1.layout=org.apache.log4j.PatternLayout

### 配置日志输出的格式##
log4j.appender.A1.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n

### 设置输出地A2到文件（文件大小到达指定尺寸的时候产生一个新的文件）##
log4j.appender.A2=org.apache.log4j.RollingFileAppender

### 文件位置##
log4j.appender.A2.File=E:/study/log4j/zhuwei.html

### 文件大小##
log4j.appender.A2.MaxFileSize=500KB

log4j.appender.A2.MaxBackupIndex=1

##指定采用html方式输出
log4j.appender.A2.layout=org.apache.log4j.HTMLLayout

二、log4j.xml

<?xml version="1.0" encoding="GB2312" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

   <appender name="com.unmi.all" class="org.apache.log4j.RollingFileAppender">
  
      <!-- 设置通道ID:com.unmi.all和输出方式：org.apache.log4j.RollingFileAppender -->
      <param name="File" value="E:/study/log4j/all.output.log" /><!-- 设置File参数：日志输出文件名 -->
      <param name="Append" value="false" /><!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->
      <param name="MaxBackupIndex" value="10" />
      <layout class="org.apache.log4j.PatternLayout">
          <param name="ConversionPattern" value="%p (%c:%L)- %m%n" /><!-- 设置输出文件项目和格式 -->
      </layout>
   </appender>
  
   <appender name="com.unmi.zcw" class="org.apache.log4j.RollingFileAppender">
      <param name="File" value="E:/study/log4j/unmi.output.log" />
      <param name="Append" value="true" />
      <param name="MaxFileSize" value="10240" /> <!-- 设置文件大小 -->
      <param name="MaxBackupIndex" value="10" />
      <layout class="org.apache.log4j.PatternLayout">
          <param name="ConversionPattern" value="%p (%c:%L)- %m%n" />
      </layout>
   </appender>
  
   <logger name="unmi.log"> <!-- 设置域名限制，即zcw.log域及以下的日志均输出到下面对应的通道中 -->
      <level value="debug" /><!-- 设置级别 -->
      <appender-ref ref="com.unmi.zcw" /><!-- 与前面的通道id相对应 -->
   </logger>
  
   <root> <!-- 设置接收所有输出的通道 -->
      <appender-ref ref="com.unmi.all" /><!-- 与前面的通道id相对应 -->
   </root>

</log4j:configuration>

三、配置文件加载方法：

对于properties文件，一般都不用手工去加载，由Log4j第一次初始化时自动就加载了

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.xml.DOMConfigurator;

public class Log4jApp {
   public static void main(String[] args) {
       DOMConfigurator.configure("E:/study/log4j/log4j.xml");//加载.xml文件
       //PropertyConfigurator.configure("E:/study/log4j/log4j.properties");//加载.properties文件

       Logger log=Logger.getLogger("com.unmi.test");
       log.info("测试");
   }
}

四、项目使用log4j

在web应用中，可以将配置文件的加载放在一个单独的servlet中，并在web.xml中配置该servlet在应用启动时候加载。对于在多人项目中，可以给每一个人设置一个输出通道，这样在每个人在构建Logger时，用自己的域名称，让调试信息输出到自己的log文件中。

五、常用输出格式

# -X号:X信息输出时左对齐；
# %p:日志信息级别
# %d{}:日志信息产生时间
# %c:日志信息所在地（类名）
# %m:产生的日志具体信息
# %n:输出日志信息换行

关于Log4j比较全面的配置
LOG4J的配置之简单使它遍及于越来越多的应用中了：Log4J配置文件实现了输出到控制台、文件、回滚文件、发送日志邮件、输出到数据库日志表、自定义标签等全套功能。择其一二使用就够用了，

log4j.rootLogger=DEBUG,CONSOLE,A1,im
log4j.addivity.org.apache=true

# 应用于控制台

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.Threshold=DEBUG
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#log4j.appender.CONSOLE.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

#应用于文件

log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=file.log
log4j.appender.FILE.Append=false
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
# Use this layout for LogFactor 5 analysis

# 应用于文件回滚

log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender
log4j.appender.ROLLING_FILE.Threshold=ERROR
log4j.appender.ROLLING_FILE.File=rolling.log
log4j.appender.ROLLING_FILE.Append=true
log4j.appender.ROLLING_FILE.MaxFileSize=10KB
log4j.appender.ROLLING_FILE.MaxBackupIndex=1
log4j.appender.ROLLING_FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.ROLLING_FILE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket
log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender
log4j.appender.SOCKET.RemoteHost=localhost
log4j.appender.SOCKET.Port=5001
log4j.appender.SOCKET.LocationInfo=true
# Set up for Log Facter 5
log4j.appender.SOCKET.layout=org.apache.log4j.PatternLayout
log4j.appender.SOCET.layout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]%n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

# Log Factor 5 Appender
log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender
log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件

log4j.appender.MAIL=org.apache.log4j.net.SMTPAppender
log4j.appender.MAIL.Threshold=FATAL
log4j.appender.MAIL.BufferSize=10
log4j.appender.MAIL.From=xxx@www.xxx.com
log4j.appender.MAIL.SMTPHost=www.wusetu.com
log4j.appender.MAIL.Subject=Log4J Message
log4j.appender.MAIL.To=xxx@www.xxx.com
log4j.appender.MAIL.layout=org.apache.log4j.PatternLayout
log4j.appender.MAIL.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test
log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver
log4j.appender.DATABASE.user=root
log4j.appender.DATABASE.password=
log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) VALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.A1.File=SampleMessages.log4j
log4j.appender.A1.DatePattern=yyyyMMdd-HH'.log4j'
log4j.appender.A1.layout=org.apache.log4j.xml.XMLLayout

输出到2000NT日志
 把Log4j压缩包里的NTEventLogAppender.dll拷到WINNT\SYSTEM32目录下

 log4j.logger.NTlog=FATAL, A8
 # APPENDER A8
 log4j.appender.A8=org.apache.log4j.nt.NTEventLogAppender
 log4j.appender.A8.Source=JavaTest
 log4j.appender.A8.layout=org.apache.log4j.PatternLayout
 log4j.appender.A8.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

#自定义Appender

log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

log4j.appender.im.host = mail.cybercorlin.net
log4j.appender.im.username = username
log4j.appender.im.password = password
log4j.appender.im.recipient = xxx@xxx.net

log4j.appender.im.layout=org.apache.log4j.PatternLayout
log4j.appender.im.layout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n