20-案例实现

案例实现

按照如下步骤来实现本案例。

1．创建 MyFormatter 类，该类实现了 java.util.logging.Formater ，并实现了抽象方法 format() ，该方法接收一个 LogRecord 对象作为参数并返回包含日志信息的字符型对象：

public class MyFormatter extends Formatter {
  @Override
  public String format(LogRecord record) {
    StringBuilder sb=new StringBuilder();
    sb.append("["+record.getLevel()+"] - ");
    sb.append(new Date(record.getMillis())+" : ");
    sb.append(record.getSourceClassName()+ "."
              +record.getSourceMethodName()+" : ");
    sb.append(record.getMessage()+"\n");.
    return sb.toString();
  }

2．创建 MyLoggerFactory 类：

public class MyLoggerFactory {

3．添加 Handler 类型的私有属性 handler ：

private static Handler handler;

4．实现 public 静态方法 getLogger() ，该方法用于生成输出日志消息的 Logger 对象。该方法接收字符型的参数 name ，并将用 synchronized 关键词对方法进行同步：

public synchronized static Logger getLogger(String name){

5．传入一个日志名称作为 Logger 类 getLogger() 方法的参数，获得一个 java. util.logging.Logger 类型的对象：

Logger logger=Logger.getLogger(name);

6．使用 setLevel() 方法，设置当前日志等级为“输出全部类型的日志”：

logger.setLevel(Level.ALL);

7．如果处理器属性为空，则创建一个 FileHandler 类型的对象，并设置输出日志到 recipe6.log ^[1]。通过 setFormatter() 方法关联 MyFormatter 类型对象到这个处理器上：

try {
  if (handler==null) {
    handler=new FileHandler("recipe6.log");
    Formatter format=new MyFormatter();
    handler.setFormatter(format);
  }

8．如果 Logger 没有关联的处理器，则通过 addHandler() 为 Logger 关联一个处理器：

    if (logger.getHandlers().length==0) {
      logger.addHandler(handler);
    }
  } catch (SecurityException e | IOException e) {
  e.printStackTrace();
}

9．返回已经创建成功的 Logger 对象：

  return logger;
}

10．创建 Task 类，该类实现了 Runnable 接口。我们将用该类测试 Logger 对象：

public class Task implements Runnable {

11．实现 run() 方法：

@Override
public void run() {

12．传入当前类的类名到 MyLogger 的 getLogger() 方法，初始化 Logger 类型对象，并命名为 logger ：

Logger logger= MyLogger.getLogger(this.getClass().getName());

13．利用 entering() 方法输出 run() 方法开始执行的信息：

logger.entering(Thread.currentThread().getName(), "run()");

14．让工作线程休眠2s：

try {
  TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
  e.printStackTrace();
}

15．用 exiting() 方法输出 run() 方法执行结束的信息：

  logger.exiting(Thread.currentThread().getName(), "run()",
                 Thread.currentThread());
}

16．实现本案例执行的主类，生成 Main 并添加 main() 方法：

public class Main {
  public static void main(String[] args) {

17．通过 MyLogger 类上的 getLogger() 方法在方法中传入类名并创建 Logger 类型的 logger 对象：

Logger logger=MyLogger.getLogger(Main.class.getName());

18．用 entering() 方法输出主函数开始执行的信息：

logger.entering(Main.class.getName(), "main()",args);

19．创建可以容纳5个 Thread 对象的数组：

Thread threads[]=new Thread[5];

20．分别创建5个 Task 对象，并且交由不同的 Thread 对象来执行。在创建一个新的线程前输出日志信息，线程创建成功后输出日志信息：

for (int i=0; i<threads.length; i++) {
  logger.log(Level.INFO,"Launching thread: "+i);
  Task task=new Task();
  threads[i]=new Thread(task);
  logger.log(Level.INFO,"Thread created: "+
             threads[i].getName());
  threads[i].start();
}

21．在所有线程创建完成后，输出日志信息：

logger.log(Level.INFO,"Ten Threads created."+
           "Waiting for its finalization");

22．分别在5个线程对象上执行 join() 方法来等待。每个线程结束后，输出一个日志消息以表明线程结束：

for (int i=0; i<threads.length; i++) {
  try {
    threads[i].join();
    logger.log(Level.INFO,"Thread has finished its execution",
               threads[i]);
  } catch (InterruptedException e) {
    logger.log(Level.SEVERE, "Exception", e);
  }
}

23．在 main() 方法执行完成后，调用 exiting() 方法输出结束信息：

  logger.exiting(Main.class.getName(), "main()");
}