---------------------- 多维数组------------------------
DECLARE

TYPE emp_type IS RECORD
( emp_id employee_table.emp_id%TYPE,
emp_name employee_table.emp_name%TYPE,
emp_gender employee_table.emp_gender%TYPE );

TYPE emp_type_array IS TABLE OF
emp_type INDEX BY BINARY_INTEGER;

emp_rec_array emp_type_array;
emp_rec emp_type;

BEGIN
emp_rec.emp_id := 300000000;
emp_rec.emp_name := 'Barbara';
emp_rec.emp_gender := 'Female';

emp_rec_array(1) := emp_rec;

emp_rec.emp_id := 300000008;
emp_rec.emp_name := 'Rick';
emp_rec.emp_gender := 'Male';

emp_rec_array(2) := emp_rec;

FOR i IN 1..emp_rec_array.count LOOP
DBMS_OUTPUT.PUT_LINE('i='||i
||', emp_id ='||emp_rec_array(i).emp_id
||', emp_name ='||emp_rec_array(i).emp_name
||', emp_gender = '||emp_rec_array(i).emp_gender);
END LOOP;

END;
-------------- Result --------------
i=1, emp_id =300000000, emp_name =Barbara, emp_gender = Female
i=2, emp_id =300000008, emp_name =Rick, emp_gender = Male

注：在PL/SQL 中是没有数组(Array) 概念的. 但是如果程序员想用Array 的话, 就得变通一下, 用TYPE 和Table of Record 来代替多维数组, 一样挺好用的。
emp_type 就好象一个table 中的一条record 一样, 里面有id, name,gender等。emp_type_array 象个table, 里面含有一条条这样的record (emp_type)，就象多维数组一样。

package com.xgll.util;                                

/**
 * <p>Title: </p>
 * <p>Description: 主要提供文件和目录操作的一些常用的方法。</p>
 * <p>Copyright: Copyright (c) 2006</p>
 * <p>Company: C-Platform</p>
 * @author wujiaqian
 * @version 1.0
 */
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class TestUtil {
   
    public TestUtil() {
    }

       /**
     * 新建目录
     * @param folderPath 目录
     * @return 返回目录创建后的路径
     */
    public String createFolder(String folderPath) {
        String txt = folderPath;
        try {
            java.io.File myFilePath = new java.io.File(txt);
            txt = folderPath;
            if (!myFilePath.exists()) {
                myFilePath.mkdir();
            }
        }
        catch (Exception e) {
           
        }
        return txt;
    }
   
    /**
     * 多级目录创建
     * @param folderPath 准备要在本级目录下创建新目录的目录路径 例如 c:myf
     * @param paths 无限级目录参数，各级目录以单数线区分 例如 a|b|c
     * @return 返回创建文件后的路径 例如 c:myfac
     */
    public String createFolders(String folderPath, String paths){
        String txts = folderPath;
        try{
            String txt;
            txts = folderPath;
            StringTokenizer st = new StringTokenizer(paths,"|");
            for(int i=0; st.hasMoreTokens(); i++){
                    txt = st.nextToken().trim();
                    if(txts.lastIndexOf("/")!=-1){
                        txts = createFolder(txts+txt);
                    }else{
                        txts = createFolder(txts+txt+"/");   
                    }
            }
       }catch(Exception e){
         
       }
        return txts;
    }

   
    /**
     * 新建文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @return
     */
    public void createFile(String filePathAndName, String fileContent) {
    
        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            FileWriter resultFile = new FileWriter(myFilePath);
            PrintWriter myFile = new PrintWriter(resultFile);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
            resultFile.close();
        }
        catch (Exception e) {
          
        }
    }

    /**
     * 有编码方式的文件创建
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @param fileContent 文本文件内容
     * @param encoding 编码方式 例如 GBK 或者 UTF-8
     * @return
     */
    public void createFile(String filePathAndName, String fileContent, String encoding) {
    
        try {
            String filePath = filePathAndName;
            filePath = filePath.toString();
            File myFilePath = new File(filePath);
            if (!myFilePath.exists()) {
                myFilePath.createNewFile();
            }
            PrintWriter myFile = new PrintWriter(myFilePath,encoding);
            String strContent = fileContent;
            myFile.println(strContent);
            myFile.close();
        }
        catch (Exception e) {
          
        }
    }

    /**
     * 删除文件
     * @param filePathAndName 文本文件完整绝对路径及文件名
     * @return Boolean 成功删除返回true遭遇异常返回false
     */
    public boolean delFile(String filePathAndName) {
     boolean flag = false;
        try {
            String filePath = filePathAndName;
            File myDelFile = new File(filePath);
            if(myDelFile.exists()){
             myDelFile.delete();
             flag = true;
            }else{
             flag = false;
   
            }
        }
        catch (Exception e) {
   
        }
        return flag;
    }
   

    /**
     * 删除文件夹
     * @param folderPath 文件夹完整绝对路径
     * @return
     */
    public void delFolder(String folderPath) {
        try {
            delAllFile(folderPath); //删除完里面所有内容
            String filePath = folderPath;
            filePath = filePath.toString();
            java.io.File myFilePath = new java.io.File(filePath);
            myFilePath.delete(); //删除空文件夹
        }
        catch (Exception e) {
   
        }
    }
   
   
    /**
     * 删除指定文件夹下所有文件
     * @param path 文件夹完整绝对路径
     * @return
     * @return
     */
    public boolean delAllFile(String path) {
     boolean flag = false;
        File file = new File(path);
        if (!file.exists()) {
            return flag;
        }
        if (!file.isDirectory()) {
            return flag;
        }
        String[] tempList = file.list();
        File temp = null;
        for (int i = 0; i < tempList.length; i++) {
            if (path.endsWith(File.separator)) {
                temp = new File(path + tempList[i]);
            }else{
                temp = new File(path + File.separator + tempList[i]);
            }
            if (temp.isFile()) {
                temp.delete();
            }
            if (temp.isDirectory()) {
                delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
                delFolder(path+"/"+ tempList[i]);//再删除空文件夹
                flag = true;
            }
        }
        return flag;
    }

    /**
     * 复制单个文件
     * @param oldPathFile 准备复制的文件源
     * @param newPathFile 拷贝到新绝对路径带文件名
     * @return
     */
    public void copyFile(String oldPathFile, String newPathFile) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPathFile);
            if (oldfile.exists()) { //文件存在时
                InputStream inStream = new FileInputStream(oldPathFile); //读入原文件
                FileOutputStream fs = new FileOutputStream(newPathFile);
                byte[] buffer = new byte[1444];
                while((byteread = inStream.read(buffer)) != -1){
                    bytesum += byteread; //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        }catch (Exception e) {
   
        }
    }
   

    /**
     * 复制整个文件夹的内容
     * @param oldPath 准备拷贝的目录
     * @param newPath 指定绝对路径的新目录
     * @return
     */
    public void copyFolder(String oldPath, String newPath) {
        try {
            new File(newPath).mkdirs(); //如果文件夹不存在 则建立新文件夹
            File a=new File(oldPath);
            String[] file=a.list();
            File temp=null;
            for (int i = 0; i < file.length; i++) {
                if(oldPath.endsWith(File.separator)){
                    temp=new File(oldPath+file[i]);
                }else{
                    temp=new File(oldPath+File.separator+file[i]);
                }
                if(temp.isFile()){
                    FileInputStream input = new FileInputStream(temp);
                    FileOutputStream output = new FileOutputStream(newPath + "/" +
                    (temp.getName()).toString());
                    byte[] b = new byte[1024 * 5];
                    int len;
                    while ((len = input.read(b)) != -1) {
                        output.write(b, 0, len);
                    }
                    output.flush();
                    output.close();
                    input.close();
                }
                if(temp.isDirectory()){//如果是子文件夹
                    copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
                }
            }
        }catch (Exception e) {
   
        }
    }

    /**
     * 移动文件
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFile(String oldPath, String newPath) {
        copyFile(oldPath, newPath);
        delFile(oldPath);
    }
   

    /**
     * 移动目录
     * @param oldPath
     * @param newPath
     * @return
     */
    public void moveFolder(String oldPath, String newPath) {
        copyFolder(oldPath, newPath);
        delFolder(oldPath);
    }

 /**
     * 读取文本文件内容
     * @param filePathAndName 带有完整绝对路径的文件名
     * @param encoding 文本文件打开的编码方式
     * @return 返回文本文件的内容
     */
    public String readTxt(String filePathAndName,String encoding) throws IOException{
     encoding = encoding.trim();
     StringBuffer str = new StringBuffer("");
     String st = "";
     try{
      FileInputStream fs = new FileInputStream(filePathAndName);
      InputStreamReader isr;
      if(encoding.equals("")){
       isr = new InputStreamReader(fs);
      }else{
       isr = new InputStreamReader(fs,encoding);
      }
      BufferedReader br = new BufferedReader(isr);
      try{
       String data = "";
       while((data = br.readLine())!=null){
         str.append(data+" ");
       }
      }catch(Exception e){
       str.append(e.toString());
      }
      st = str.toString();
     }catch(IOException es){
      st = "";
     }
     return st;    
    }
  
}

						
Properties props = new Properties();
// fill props with any information
Session session = Session.getDefaultInstance(props, null);

Properties props = new Properties();
// fill props with any information
Session session = Session.getInstance(props, null);

MimeMessage message = new MimeMessage(session);

message.setContent("Hello", "text/plain");

message.setText("Hello");

message.setSubject("First");

Address address = new InternetAddress("president@whitehouse.gov"); 

Address address = new InternetAddress("president@whitehouse.gov", "George Bush"); 

message.setFrom(address);
message.setReplyTo(address);

Address address[] = ...;
message.addFrom(address);

message.addRecipient(type, address)

Address toAddress = new InternetAddress("vice.president@whitehouse.gov");
Address ccAddress = new InternetAddress("first.lady@whitehouse.gov");
message.addRecipient(Message.RecipientType.TO, toAddress);
message.addRecipient(Message.RecipientType.CC, ccAddress);

Properties props = new Properties();
// fill props with any information
Authenticator auth = new MyAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

Transport.send(message);

message.saveChanges(); // implicit with send()
Transport transport = session.getTransport("smtp");
transport.connect(host, username, password);
transport.sendMessage(message, message.getAllRecipients());
transport.close();

session.setDebug(true)。

// Store store = session.getStore("imap");
Store store = session.getStore("pop3");
store.connect(host, username, password);

Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);
Message message[] = folder.getMessages();

System.out.println(((MimeMessage)message).getContent());

folder.close(aBoolean);
store.close();

String host = ...;
String from = ...;
String to = ...;

// Get system properties
Properties props = System.getProperties();

// Setup mail server
props.put("mail.smtp.host", host);

// Get session
Session session = Session.getDefaultInstance(props, null);

// Define message
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail");
message.setText("Welcome to JavaMail");
// Send message
Transport.send(message);

String host = ...;
String username = ...;
String password = ...;

// Create empty properties
Properties props = new Properties();

// Get session
Session session = Session.getDefaultInstance(props, null);

// Get the store
Store store = session.getStore("pop3");
store.connect(host, username, password);

// Get folder
Folder folder = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// Get directory
Message message[] = folder.getMessages();

for (int i=0, n=message.length; i<n; i++) {
   System.out.println(i + ": " + message[i].getFrom()[0] 
     + "\t" + message[i].getSubject());
}

// Close connection 
folder.close(false);
store.close();

BufferedReader reader = new BufferedReader (
  new InputStreamReader(System.in));

// Get directory
Message message[] = folder.getMessages();
for (int i=0, n=message.length; i<n; i++) {
  System.out.println(i + ": " + message[i].getFrom()[0] 
    + "\t" + message[i].getSubject());

  System.out.println("Do you want to read message? " +
    "[YES to read/QUIT to end]");
  String line = reader.readLine();
  if ("YES".equals(line)) {
    message[i].writeTo(System.out);
  } else if ("QUIT".equals(line)) {
    break;
  }
}

message.setFlag(Flags.Flag.DELETED, true);

folder.open(Folder.READ_WRITE);

folder.close(true);

// Setup properties
Properties props = System.getProperties();
props.put("mail.pop3.host", host);

// Setup authentication, get session
Authenticator auth = new PopupAuthenticator();
Session session = Session.getDefaultInstance(props, auth);

// Get the store
Store store = session.getStore("pop3");
store.connect();

import javax.mail.*;
import java.util.*;

public class PopupAuthenticator extends Authenticator {

  public PasswordAuthentication getPasswordAuthentication(String param) {
    String username, password;

    StringTokenizer st = new StringTokenizer(param, ",");
    username = st.nextToken();
    password = st.nextToken();

    return new PasswordAuthentication(username, password);
  }

}

MimeMessage reply = (MimeMessage)message.reply(false);
reply.setFrom(new InternetAddress("president@whitehouse.gov"));
reply.setText("Thanks");
Transport.send(reply);

// Create the message to forward
Message forward = new MimeMessage(session);

// Fill in header
forward.setSubject("Fwd: " + message.getSubject());
forward.setFrom(new InternetAddress(from));
forward.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(
  "Here you go with the original message:\n\n");

// Create a multi-part to combine the parts
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Create and fill part for the forwarded content
messageBodyPart = new MimeBodyPart();
messageBodyPart.setDataHandler(message.getDataHandler());

// Add part to multi part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
forward.setContent(multipart);

// Send message
Transport.send(forward);

// Define message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));
message.setSubject("Hello JavaMail Attachment");

// Create the message part 
BodyPart messageBodyPart = new MimeBodyPart();

// Fill the message
messageBodyPart.setText("Pardon Ideas");

Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);

// Part two is attachment
messageBodyPart = new MimeBodyPart();
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);

// Put parts in message
message.setContent(multipart);

// Send the message
Transport.send(message);

<FORM ENCTYPE="multipart/form-data" 
    method=post action="/myservlet"> 
  <INPUT TYPE="file" NAME="thefile">
  <INPUT TYPE="submit" VALUE="Upload">
</FORM>

Multipart mp = (Multipart)message.getContent();

for (int i=0, n=multipart.getCount(); i<n; i++) {
  Part part = multipart.getBodyPart(i));

  String disposition = part.getDisposition();

  if ((disposition != null) && 
      ((disposition.equals(Part.ATTACHMENT) || 
       (disposition.equals(Part.INLINE))) {
    saveFile(part.getFileName(), part.getInputStream());
  }
}

// from saveFile()
File file = new File(filename);
for (int i=0; file.exists(); i++) {
  file = new File(filename+i);
}

if (disposition == null) {
  // Check if plain
  MimeBodyPart mbp = (MimeBodyPart)part;
  if (mbp.isMimeType("text/plain")) {
    // Handle plain
  } else {
    // Special non-attachment cases here of 
    // image/gif, text/html, ...
  }
...
}

String htmlText = "<H1>Hello</H1>" + 
  "<img src=\"http://www.jguru.com/images/logo.gif\">";
message.setContent(htmlText, "text/html"));

if (message.getContentType().equals("text/html")) {
  String content = (String)message.getContent();
  JFrame frame = new JFrame();
  JEditorPane text = new JEditorPane("text/html", content);
  text.setEditable(false);
  JScrollPane pane = new JScrollPane(text);
  frame.getContentPane().add(pane);
  frame.setSize(300, 300);
  frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  frame.show();
}

String file = ...;

// Create the message
Message message = new MimeMessage(session);

// Fill its headers
message.setSubject("Embedded Image");
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, 
  new InternetAddress(to));

// Create your new message part
BodyPart messageBodyPart = new MimeBodyPart();
String htmlText = "<H1>Hello</H1>" + 
  "<img src=\"cid:memememe\">";
messageBodyPart.setContent(htmlText, "text/html");

// Create a related multi-part to combine the parts
MimeMultipart multipart = new MimeMultipart("related");
multipart.addBodyPart(messageBodyPart);

// Create part for the image
messageBodyPart = new MimeBodyPart();

// Fetch the image and associate to part
DataSource fds = new FileDataSource(file);
messageBodyPart.setDataHandler(new DataHandler(fds));
messageBodyPart.setHeader("Content-ID","<memememe>");

// Add part to multi-part
multipart.addBodyPart(messageBodyPart);

// Associate multi-part with message
message.setContent(multipart);

SearchTerm st = ...;
Message[] msgs = folder.search(st);

SearchTerm st = 
  new OrTerm(
    new SubjectTerm("ADV:"), 
    new FromStringTerm("friend@public.com"));
Message[] msgs = folder.search(st);

public static void main(String［］ args) {//自己替换［］

  System.setProperty("org.apache.commons.logging.Log",
      "org.apache.commons.logging.impl.Jdk14Logger");
  Log log = LogFactory.getLog("com.discursive.jccook.SomeApp");

  if (log.isTraceEnabled()) {
    log.trace("This is a trace message");
  }

  if (log.isDebugEnabled()) {
    log.debug("This is a debug message");
  }

  log.info("This is an informational message");
  log.warn("This is a warning");
  log.error("This is an error");
  log.fatal("This is fatal");

}

　　一、定义配置文件

　　其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

　　1.配置根Logger，其语法为：

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

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

　　2.配置日志信息输出目的地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（将日志信息以流格式发送到任意指定的地方）

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

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

　　二、在代码中使用Log4j

　　1.得到记录器

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

　　public static Logger getLogger( String name)

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

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

　　2.读取配置文件

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

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

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

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

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


介绍
命令行参数解析、应用程序配置和日志记录，作为一个应用程序的骨架，随处可见。因此，Apache软件组织开发出了一套通用的类库，用来帮助软件开发人员完成这些“骨架”的建立。其中：
&#8226;Commons CLI用于命令行解析
&#8226;Commons Configuration用于读取properties格式或者XML格式的配置信息
&#8226;Commons Logging和Log4J用来提供日志支持。
这些通用的类库都在http://jakarta.apache.org/commons/index.html网址上提供下载

Log4J是一个高度可配置的Logging框架，提供了结构化，多种目标和格式支持。

&#8226;配置Log4J
问题：
Log4J支持Properties和XML两种格式的配置文件。
解决方案：
定义log4j.properties配置文件

# 所有Log信息输出到标准输出(System.out)和在下面指定的一个文件
# WARN是默认的logging级别
log4j.rootCategory = WARN, STDOUT, FILE

# 应用程序的logging级别是DEBUG
log4j.logger.com.discursive = DEBUG

# 配置标准输出Appender
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

# 配置输出文件Appender
log4j.appender.FILE = org.apache.log4j.RollingFileAppender
log4j.appender.FILE.File = output.log
log4j.appender.FILE.MaxFileSize = 2000KB
log4j.appender.FILE.MaxBackupIndex = 5
log4j.appender.FILE.layout = org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern = %d %-5p %c - %m%n

PropertyConfigurator.configure(getClass()
  .getResource("/resources/log4j.properties"));

Logger logger = Logger.getLogger("com.discursive.SomeApp");
logger.info("This is a info message");
logger.error("This is a error message");

使用BasicConfigurator类来加载log4j.properties配置。使用Logger.getLogger获得一个logger实例。
配置文件中的rootCategory指定将log输出到控制台和output.log文件。文件Appender使用了RollingFileAppender，当文件大小达到最大文件大小(MaxFileSize)2000KB时，RollingFileAppender会备份原log文件，并再创建一个新的log文件。
配置文件指定默认的logging级别是DEBUG(log4j.logger.com.discursive = DEBUG)。所以，所有级别低于DEBUG的log信息都不会被输出。Log4J按重要度定义了五个log级别，分别是：DEBUG, INFO, WARN, ERROR, 和FATAL。
其他：
Log4J还可以使用XML格式的配置文件，使用DOMConfigurator读取。
Log4J使用Appender和Layout来定制log输出。Appender指定输出到何处，Layout指定如何输出(输出的格式)。
Log4J内置的Appender有：
&#8226;SMTPAppender
&#8226;RollingFileAppender
&#8226;SocketAppender
&#8226;SyslogAppender
&#8226;NTEventLogAppender
Log4J支持的Layout有
&#8226;XMLLayout
&#8226;PatternLayout
&#8226;HTMLLayout
&#8226;DateLayout.


附1
# 所有Log信息输出到标准输出(System.out)和在下面指定的一个文件
# WARN是默认的logging级别
log4j.rootCategory = INFO, STDOUT
#log4j.rootCategory = INFO, STDOUT, FILE

# 配置标准输出Appender
log4j.appender.STDOUT = org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.layout = org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.ConversionPattern = %d{ABSOLUTE} %-5p [%c:%L] %m%n

# 配置输出文件Appender
log4j.appender.FILE = org.apache.log4j.RollingFileAppender
log4j.appender.FILE.File = output.log
log4j.appender.FILE.MaxFileSize = 2000KB
log4j.appender.FILE.MaxBackupIndex = 5
log4j.appender.FILE.layout = org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern = %d %-5p [%c:%L] %m%n

# 应用程序的logging级别是DEBUG
log4j.logger.com.xzc = DEBUG


附2
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - <%m>%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

log4j.logger.net.sf.hibernate=warn

### log just the SQL
#log4j.logger.net.sf.hibernate.SQL=debug

### log JDBC bind parameters ###
log4j.logger.net.sf.hibernate.type=info

### log schema export/update ###
log4j.logger.net.sf.hibernate.tool.hbm2ddl=debug

### log cache activity ###
#log4j.logger.net.sf.hibernate.cache=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace

附3

log4j.rootLogger=debug, stdout, R

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

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=100KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n





 附4
# Log4j由三个重要的组件构成：日志信息的优先级，日志信息的输出目的地，日志信息的输出格式

# 1.配置根Logger，其语法为：
#　　log4j.rootLogger = [ level ] , appenderName, appenderName, … 

# 2.配置日志信息输出目的地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（将日志信息以流格式发送到任意指定的地方）

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

# 所有Log信息输出到标准输出(System.out)和在下面指定的一个文件 
# 日志信息的优先级从从高到低有ERROR、WARN、INFO、DEBUG
# WARN是默认的logging级别
log4j.rootCategory = INFO, STDOUT
#log4j.rootCategory = INFO, STDOUT, FILE
#log4j.rootCategory = INFO, STD
 
# 配置标准输出Appender
log4j.appender.STDOUT = org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.layout = org.apache.log4j.PatternLayout
#log4j.appender.STDOUT.layout.ConversionPattern = %d{ABSOLUTE} %-5p [%c:%t:%L] %m%n
log4j.appender.STDOUT.layout.ConversionPattern = %d{ABSOLUTE} %-5p [ %l ] %m%n

# 配置输出文件Appender
log4j.appender.FILE = org.apache.log4j.RollingFileAppender
log4j.appender.FILE.File = output.log
log4j.appender.FILE.MaxFileSize = 2000KB
log4j.appender.FILE.MaxBackupIndex = 5
log4j.appender.FILE.layout = org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.ConversionPattern = %d %-5p [%c:%L] %m%n

# 配置默认输出layout
log4j.appender.STD = org.apache.log4j.ConsoleAppender
log4j.appender.STD.layout = org.apache.log4j.TTCCLayout

# 应用程序的logging级别是DEBUG
log4j.logger.com.xzc = DEBUG

Java提供了两类主要的异常：runtime exception和checked exception。所有的checked exception是从java.lang.Exception类衍生出来的，而runtime exception则是从java.lang.RuntimeException或java.lang.Error类衍生出来的。

它们的不同之处表现在两方面：机制上和逻辑上。

　　一、机制上

　　它们在机制上的不同表现在两点：1.如何定义方法；2. 如何处理抛出的异常。请看下面CheckedException的定义：

 class HighLevelException extends Exception {
     HighLevelException(Throwable cause) { super(cause); }
     HighLevelException(String message,Throwable cause) {
      super(message,cause);
     }
 }

 class MidLevelException extends Exception {
     MidLevelException(Throwable cause)  { super(cause); }
     MidLevelException(String message,Throwable cause)  {
      super(message,cause);
     }
 }
 
 class LowLevelException extends Exception {
  public LowLevelException(){
  }
  public LowLevelException(String message){
   super(message);
  }
 }