轩辕斩仙剑
轩辕斩仙剑

Java日志体系---JUL源码解析

在软件开发过程中日志记录是必不可少的一部分。作为一个合格的软件开发者（Java），有必要深入了解一下Java的日志体系。本文将详细的介绍我在学习JUL时的一些方法和心得。

一般来说日志分为两种：业务日志和异常日志，使用日志我们希望能达到以下目标：

  • 对程序运行情况的记录和监控；
  • 在必要时可详细了解程序内部的运行状态；
  • 对系统性能的影响尽量小；

个人觉得记录日志最重要的目的在于记录程序运行的信息，以方便分析程序的运行结果和定位问题。

概览（查、看、跑、造、比、买）

梳理了自己学习JUL的过程，并进行总结，以便在学习其他技术时也能使用这种学习方法。

  1. 查API
    查看官方API，对这个技术的整体以及核心类的介绍有所了解。
  2. 看源码
    根据API的介绍查看核心类的代码，去繁存简只研究与日志相关的部分
    （例如，本文将忽略安全、多线程、本地化相关的代码 ）
  3. 跑程序
    从helloworld开始，将核心功能串联起来。
  4. 造轮子
    梳理清楚逻辑后，关闭浏览器(这时候应该放下资料),打开IDE按照自己的理解实现这个功能。
  5. 货比三家
    研究同种类型技术的实现方式。
  6. 买定离手
    对比不同技术的性能和适用场景，技术选型。

查API

软件包 java.util.logging 的描述
提供 JavaTM 2 平台核心日志工具的类和接口。Logging API 的中心目标是支持在客户站点进行软件的维护和服务。
使用日志有 4 个主要目标：
1.由最终用户和系统管理员进行问题诊断。这由简单的常见问题日志组成，可在本地解决或跟踪这些问题，如资源不足、安全失败和简单的配置错误。
2.由现场服务工程师进行问题诊断。现场服务工程师使用的日志信息可以相当复杂和冗长，远超过系统管理员的要求。通常，这样的信息需要特定子系统中的额外日志记录。
3.由开发组织进行问题诊断。在现场出现问题时，必须将捕获的日志信息返回到原开发团队以供诊断。此日志信息可能非常详细，并且相当费解。这样的信息可能包括对特定子系统进行内部执行的详细跟踪。
4.由开发人员进行问题诊断。Logging API 还可以用来帮助调试正在开发的应用程序。这可能包括由目标应用程序产生的日志信息，以及由低级别的库产生的日志信息。但是要注意，虽然这样使用非常合理，但是 Logging API 并不用于代替开发环境中已经存在的调试和解析工具。
此包的关键元素包括：
Logger：应用程序进行 logging 调用的主要实体。Logger 对象用来记录特定系统或应用程序组件的日志消息。
LogRecord：用于在 logging 框架和单独的日志处理程序之间传递 logging 请求。
Handler：将 LogRecord 对象导出到各种目的地，包括内存、输出流、控制台、文件和套接字。为此有各种的 Handler 子类。其他 Handler 可能由第三方开发并在核心平台的顶层实现。
Level：定义一组可以用来控制 logging 输出的标准 logging 级别。可以配置程序为某些级别输出 logging，而同时忽略其他输出。
Filter：为所记录的日志提供日志级别控制以外的细粒度控制。Logging API 支持通用的过滤器机制，该机制允许应用程序代码附加任意的过滤器以控制 logging 输出。
Formatter：为格式化 LogRecord 对象提供支持。此包包括的两个格式器 SimpleFormatter 和 XMLFormatter 分别用于格式化纯文本或 XML 中的日志记录。与 Handler 一样，其他 Formatter 可能由第三方开发。
Logging API 提供静态和动态的配置控制。静态控制使现场服务人员可以建立特定的配置，然后重新启动带有新 logging 设置的应用程序。动态控制允许对当前正在运行的系统内的 logging 配置进行更新。API 也允许对不同的系统功能领域启用或禁用 logging。例如，现场服务工程师可能对跟踪所有 AWT 事件感兴趣，但是不会对套接字事件或内存管理感兴趣。

从JDK(java.util.logging)的API中可以看出：

  • Logger是用来记录日志的，
  • LogRecord是用来传递日志的，
  • Handler是用来导出（处理）日志的，
  • Level是用来定义日志级别的（控制日志输出），
  • Filter提供了日志级别之外更细粒度的控制，
  • Formatter是用来格式化LogRecord的，
  • 此外还有一个单一的全局的LogManager维护Logger和管理日志。

JUL主要由这七个核心类或接口组成，再有就是一些子类或者实现类。API中关于这几个类或接口的类和方法的详细介绍这里不再复述。
现在我们已经对JUL有了一个整体的了解，并且对核心类或接口的功能职责也有了初步了解，接下就该结合代码看看JUL的真面目。
Java日志体系---JUL源码解析_第1张图片

看源码

找到rt.jar,打开java.util.logging包查看每个类的源代码,结合JUL流程示意图逐个介绍。
1.Logger类

package java.util.logging;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import sun.reflect.Reflection;
public class Logger {
    //------------------------------属性------------------------------------------
    private String name;//日志名称
    private static final int offValue = Level.OFF.intValue();
    // We keep weak references from parents to children, but strong
    // references from children to parents.
    private volatile Logger parent;    // our nearest parent.
    private ArrayList kids;   // WeakReferences to loggers that have us as parent
    //内部类LoggerBundle相关部分忽略

    private volatile LogManager manager;

    private static final Handler emptyHandlers[] = new Handler[0];
    private final CopyOnWriteArrayList handlers =
            new CopyOnWriteArrayList<>();
    private volatile boolean useParentHandlers = true;

    private volatile Filter filter;

    private volatile Level levelObject;
    private volatile int levelValue;  // current effective level value

    private static final Object treeLock = new Object();
    private final boolean isSystemLogger;

    //------------------------------构造器------------------------------------------
  //只保留一个简单的私有构造器
    private Logger(String name) {
        // The manager field is not initialized here.
        this.name = name;
        this.isSystemLogger = true;
        levelValue = Level.INFO.intValue();//初始化级别INFO
    }
    //------------------------------方法------------------------------------------
    //获取Logger的name
    public String getName() {
        return name;
    }
    // It is called from LoggerContext.addLocalLogger() when the logger
    // is actually added to a LogManager.
    //--------------设置和初始化LogManager，包权限的方法-------------
    void setLogManager(LogManager manager) {
        this.manager = manager;
    }
    private void checkPermission() throws SecurityException {
        if (manager == null) {
            // Complete initialization of the global Logger.
            manager = LogManager.getLogManager();
        }
        manager.checkPermission();
    }

    //-------------------获取Logger的工厂方法----------------------
    public static Logger getLogger(String name) {
        //获取需要的Logger
        return demandLogger(name, null, Reflection.getCallerClass());
    }
    private static Logger demandLogger(String name, String resourceBundleName, Class caller) {
        //初始化LogManager
        LogManager manager = LogManager.getLogManager();
//        SecurityManager sm = System.getSecurityManager();
//        if (sm != null) {
//            if (caller.getClassLoader() == null) {
//                return manager.demandSystemLogger(name, resourceBundleName);
//            }
//        }
        //
        //通过LogManager获取需要的Logger
        return manager.demandLogger(name, resourceBundleName, caller);
    }

    //--------------------Filter的方法----------------------
    public void setFilter(Filter newFilter) throws SecurityException {
        //校验权限和初始化LogManager
        checkPermission();
        filter = newFilter;
    }
    public Filter getFilter() {
        return filter;
    }

    //--------------------记录日志的方法----------------------
    // 核心的日志操作方法，handler.publish(record);将LogRecord添加到handlers中
    public void log(LogRecord record) {
        //校验Level
        if (!isLoggable(record.getLevel())) {
            return;
        }
        //校验Filter
        Filter theFilter = filter;
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }
        Logger logger = this;
        while (logger != null) {
            final Handler[] loggerHandlers = isSystemLogger
                    ? logger.accessCheckedHandlers()
                    : logger.getHandlers();

            for (Handler handler : loggerHandlers) {
                handler.publish(record);
            }
            final boolean useParentHdls = isSystemLogger
                    ? logger.useParentHandlers
                    : logger.getUseParentHandlers();

            if (!useParentHdls) {
                break;
            }
            logger = isSystemLogger ? logger.parent : logger.getParent();
        }
    }
    private void doLog(LogRecord lr) {
        lr.setLoggerName(name);
        //忽略LogBundle
        log(lr);
    }
    public void log(Level level, String msg) {
        if (!isLoggable(level)) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);
    }
    public void log(Level level, String msg, Object param1) {
        if (!isLoggable(level)) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        Object params[] = { param1 };
        lr.setParameters(params);
        doLog(lr);
    }
    public void log(Level level, String msg, Object params[]) {
        if (!isLoggable(level)) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        lr.setParameters(params);
        doLog(lr);
    }

    //------------------日志级别相关-----------------------
    public void setLevel(Level newLevel) throws SecurityException {
        checkPermission();
        synchronized (treeLock) {
            levelObject = newLevel;
            updateEffectiveLevel();
        }
    }
    final boolean isLevelInitialized() {
        return levelObject != null;
    }
    public Level getLevel() {
        return levelObject;
    }
    //校验Level
    public boolean isLoggable(Level level) {
        if (level.intValue() < levelValue || levelValue == offValue) {
            return false;
        }
        return true;
    }
    //------------------Handler相关-----------------------
    public void addHandler(Handler handler) throws SecurityException {
        // Check for null handler
        handler.getClass();
        checkPermission();
        handlers.add(handler);
    }
    public void removeHandler(Handler handler) throws SecurityException {
        checkPermission();
        if (handler == null) {
            return;
        }
        handlers.remove(handler);
    }
    public Handler[] getHandlers() {
        return accessCheckedHandlers();
    }
    Handler[] accessCheckedHandlers() {
        return handlers.toArray(emptyHandlers);
    }

    //------------------父级日志相关-----------------------
    public Logger getParent() {
        return parent;
    }
    public void setParent(Logger parent) {
        if (parent == null) {
            throw new NullPointerException();
        }
        // check permission for all loggers, including anonymous loggers
        if (manager == null) {
            manager = LogManager.getLogManager();
        }
        manager.checkPermission();
        doSetParent(parent);
    }
    private void doSetParent(Logger newParent) {
        synchronized (treeLock) {
            // Remove ourself from any previous parent.
            LogManager.LoggerWeakRef ref = null;
            if (parent != null) {
                // assert parent.kids != null;
                for (Iterator iter = parent.kids.iterator(); iter.hasNext(); ) {
                    ref = iter.next();
                    Logger kid =  ref.get();
                    if (kid == this) {
                        // ref is used down below to complete the reparenting
                        iter.remove();
                        break;
                    } else {
                        ref = null;
                    }
                }
                // We have now removed ourself from our parents' kids.
            }
            // Set our new parent.
            parent = newParent;
            if (parent.kids == null) {
                parent.kids = new ArrayList<>(2);
            }
            if (ref == null) {
                // we didn't have a previous parent
                ref = manager.new LoggerWeakRef(this);
            }
            ref.setParentRef(new WeakReference<>(parent));
            parent.kids.add(ref);
            // As a result of the reparenting, the effective level
            // may have changed for us and our children.
            updateEffectiveLevel();
        }
    }
    private void updateEffectiveLevel() {
        // Figure out our current effective level.
        int newLevelValue;
        if (levelObject != null) {
            newLevelValue = levelObject.intValue();
        } else {
            if (parent != null) {
                newLevelValue = parent.levelValue;
            } else {
                // This may happen during initialization.
                newLevelValue = Level.INFO.intValue();
            }
        }
        // If our effective value hasn't changed, we're done.
        if (levelValue == newLevelValue) {
            return;
        }
        levelValue = newLevelValue;
        // Recursively update the level on each of our kids.
        if (kids != null) {
            for (int i = 0; i < kids.size(); i++) {
                LogManager.LoggerWeakRef ref = kids.get(i);
                Logger kid =  ref.get();
                if (kid != null) {
                    kid.updateEffectiveLevel();
                }
            }
        }
    }
}

Logger中的核心属性：

 	String name；
 	Logger parent；
 	ArrayList kids;
	LogManager manager;
	CopyOnWriteArrayList handlers；
	Filter filter;
 	Level levelObject;

Logger中的核心方法：

//-----------------------------获取日志个工厂方法---------------------------------
   public static Logger getLogger(String name) {
        //获取需要的Logger
        return demandLogger(name, null, Reflection.getCallerClass());
    }
    private static Logger demandLogger(String name, String resourceBundleName, Class caller) {
        //初始化LogManager
        LogManager manager = LogManager.getLogManager();
//        SecurityManager sm = System.getSecurityManager();
//        if (sm != null) {
//            if (caller.getClassLoader() == null) {
//                return manager.demandSystemLogger(name, resourceBundleName);
//            }
//        }
        //
        //通过LogManager获取需要的Logger
        return manager.demandLogger(name, resourceBundleName, caller);
    }


//-----------------------------记录日志的相关方法--------------------------------------
    public void log(Level level, String msg) {
        if (!isLoggable(level)) {
            return;
        }
        LogRecord lr = new LogRecord(level, msg);
        doLog(lr);
    }
  private void doLog(LogRecord lr) {
        lr.setLoggerName(name);
        //忽略LogBundle
        log(lr);
    }
    // 核心的日志操作方法，handler.publish(record);将LogRecord添加到handlers中
    public void log(LogRecord record) {
        //校验Level
        if (!isLoggable(record.getLevel())) {
            return;
        }
        //校验Filter
        Filter theFilter = filter;
        if (theFilter != null && !theFilter.isLoggable(record)) {
            return;
        }
        Logger logger = this;
        while (logger != null) {
            final Handler[] loggerHandlers = isSystemLogger
                    ? logger.accessCheckedHandlers()
                    : logger.getHandlers();

            for (Handler handler : loggerHandlers) {
                handler.publish(record);
            }
            final boolean useParentHdls = isSystemLogger
                    ? logger.useParentHandlers
                    : logger.getUseParentHandlers();

            if (!useParentHdls) {
                break;
            }
            logger = isSystemLogger ? logger.parent : logger.getParent();
        }
    }

梳理代码中的核心部分（忽略了安全、线程、ResourceBundle等部分），限于篇幅以下只列出核心的属性和方法。
Logger类中是JUL体系的核心，主要包括几个重要的属性和两个核心的方法，阅读起来不太复杂。而LogManager内容较多，放在最后介绍。
2.Level类
Level中的核心属性：

	String name;
	int value;
	String resourceBundleName;
	Level OFF;
	Level WARNING;
	Level INFO;
	Level ALL;

Level中的核心方法：通过name获取Level

//-----------------------------核心方法------------------------------
    static Level findLevel(String name) {
        if (name == null) {
            throw new NullPointerException();
        }
        KnownLevel level;
        // Look for a known Level with the given non-localized name.
        level = KnownLevel.findByName(name);
        if (level != null) {
            return level.mirroredLevel;
        }
        try {
            int x = Integer.parseInt(name);
            level = KnownLevel.findByValue(x);
            if (level == null) {
                // add new Level
                Level levelObject = new Level(name, x);
                level = KnownLevel.findByValue(x);
            }
            return level.mirroredLevel;
        } catch (NumberFormatException ex) {
            // Not an integer.
            // Drop through.
        }
//        level = KnownLevel.findByLocalizedLevelName(name);
//        if (level != null) {
//            return level.mirroredLevel;
//        }
        return null;
    }

Level中的核心内部类：KnownLevel，日志级别的容器

static final class KnownLevel {
        private static Map> nameToLevels = new HashMap<>();
        private static Map> intToLevels = new HashMap<>();
        final Level levelObject;     // instance of Level class or Level subclass
        final Level mirroredLevel;   // mirror of the custom Level
        KnownLevel(Level l) {
            this.levelObject = l;
            if (l.getClass() == Level.class) {
                this.mirroredLevel = l;
            } else {
                // this mirrored level object is hidden
                this.mirroredLevel = new Level(l.name, l.value, l.resourceBundleName, false);
            }
        }
        static synchronized void add(Level l) {
            // the mirroredLevel object is always added to the list
            // before the custom Level instance
            KnownLevel o = new KnownLevel(l);
            List list = nameToLevels.get(l.name);
            if (list == null) {
                list = new ArrayList<>();
                nameToLevels.put(l.name, list);
            }
            list.add(o);
            list = intToLevels.get(l.value);
            if (list == null) {
                list = new ArrayList<>();
                intToLevels.put(l.value, list);
            }
            list.add(o);
        }
        static synchronized KnownLevel findByName(String name) {
            List list = nameToLevels.get(name);
            if (list != null) {
                return list.get(0);
            }
            return null;
        }
        static synchronized KnownLevel findByValue(int value) {
            List list = intToLevels.get(value);
            if (list != null) {
                return list.get(0);
            }
            return null;
        }
    }

Level类中属性和方法不多，重点在KnownLevel这个内部容器类。
3.LogRecord类
LogRecord的核心属性 ：

	private static final AtomicLong globalSequenceNumber=new AtomicLong(0);
	private long sequenceNumber;
	private Level level;
	private String message;
	private String loggerName;
	private transient Object parameters[];
	private String sourceClassName;
	private String sourceMethodName;

LogRecord的构造器：

 public LogRecord(Level level, String message){
        this.level = level;
        this.message=message;
        this.sequenceNumber=globalSequenceNumber.getAndIncrement();
    }

LogRecord类相对简单，值得关注的是属性和构造器。
4.Filter接口（函数式接口）

public boolean isLoggable(LogRecord record);

主要是验证LogReocord是否能够继续传递。

5.Handler抽象类： 处理LogRecord并输出

Handler的核心属性：

	private static final int offValue = Level.OFF.intValue();
	private final LogManager manager = LogManager.getLogManager();
	private volatile Filter filter;
	private volatile Formatter formatter;
	private volatile Level logLevel = Level.ALL;

Handler的核心方法：

	//---------------------抽象方法------------------------
 	public abstract void publish(LogRecord record);
    public abstract void flush();
    public abstract void close() throws SecurityException;
	//--------------------主要方法--------------------------
	 public boolean isLoggable(LogRecord record) {
        final int levelValue = getLevel().intValue();
        if (record.getLevel().intValue() < levelValue || levelValue == offValue) {
            return false;
        }
        final Filter filter = getFilter();
        if (filter == null) {
            return true;
        }
        return filter.isLoggable(record);
    }

Handler是抽象类，JUL中提供的子类有MemoryHandler, StreamHandler。
6.Formatter抽象类

Formatter的核心方法：

	public abstract String format(LogRecord record);

    public synchronized String formatMessage(LogRecord record) {
        String format = record.getMessage();
        // Do the formatting.
        try {
            Object parameters[] = record.getParameters();
            if (parameters == null || parameters.length == 0) {
                // No parameters.  Just return format string.
                return format;
            }
            // Is it a java.text style format?
            // Ideally we could match with
            // Pattern.compile("\\{\\d").matcher(format).find())
            // However the cost is 14% higher, so we cheaply check for
            // 1 of the first 4 parameters
            if (format.indexOf("{0") >= 0 || format.indexOf("{1") >=0 ||
                    format.indexOf("{2") >=0|| format.indexOf("{3") >=0) {
                return java.text.MessageFormat.format(format, parameters);
            }
            return format;

        } catch (Exception ex) {
            // Formatting failed: use localized format string.
            return format;
        }
    }

Formatter抽象类JUL提供的子类有SimpleFormatter, XMLFormatter。

7.LogManager类

LogManager的核心属性：

    //---------------------------核心属性--------------------------------------
    private static final LogManager manager;// 全局的LogManager对象
    private volatile Properties props = new Properties(); //配置
    private final static Level defaultLevel = Level.INFO;//默认日志级别
    private final Map listenerMap = new HashMap<>();//负责存储监听
    // LoggerContext for system loggers and user loggers
    private final LoggerContext userContext = new LoggerContext();
    private volatile Logger rootLogger;//根日志
    private volatile boolean readPrimordialConfiguration;//读取原始配置
    // Have we initialized global (root) handlers yet?
    // This gets set to false in readConfiguration
    private boolean initializedGlobalHandlers = true;
    // True if JVM death is imminent and the exit hook has been called.
    private boolean deathImminent;

LogManager的静态代码块：

//---------------------------------静态代码块----------------------------------------
    static {
        manager = AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public LogManager run() {
                LogManager mgr = null;
                String cname = null;
                try {
                    cname = System.getProperty("java.util.logging.manager");
                    if (cname != null) {
                        try {
                            Class clz = ClassLoader.getSystemClassLoader()
                                    .loadClass(cname);
                            mgr = (LogManager) clz.newInstance();
                        } catch (ClassNotFoundException ex) {
                            Class clz = Thread.currentThread()
                                    .getContextClassLoader().loadClass(cname);
                            mgr = (LogManager) clz.newInstance();
                        }
                    }
                } catch (Exception ex) {
                    System.err.println("Could not load Logmanager \"" + cname + "\"");
                    ex.printStackTrace();
                }
                //确保初始化一个全局的LogManager
                if (mgr == null) {
                    mgr = new LogManager();
                }
                return mgr;
            }
        });
    }

LogManager的核心内部类：

 //LoggerContext日志上下文信息包括：Hashtable namedLoggers和LogNode root;
    class LoggerContext {
        // Table of named Loggers that maps names to Loggers.
        private final Hashtable namedLoggers = new Hashtable<>();
        // Tree of named Loggers
        private final LogNode root;
        private LoggerContext() {
            this.root = new LogNode(null, this);
        }
        final LogManager getOwner() {
            return LogManager.this;
        }
        final Logger getRootLogger() {
            return getOwner().rootLogger;
        }
        synchronized Logger findLogger(String name) {
            // ensure that this context is properly initialized before looking for loggers.
            LoggerWeakRef ref = namedLoggers.get(name);
            if (ref == null) {
                return null;
            }
            Logger logger = ref.get();
            return logger;
        }
        synchronized void removeLoggerRef(String name, LoggerWeakRef ref) {
            namedLoggers.remove(name, ref);
        }
        synchronized Enumeration getLoggerNames() {
            return namedLoggers.keys();
        }
        LogNode getNode(String name) {
            if (name == null || name.equals("")) {
                return root;
            }
            LogNode node = root;
            while (name.length() > 0) {
                int ix = name.indexOf(".");
                String head;
                if (ix > 0) {
                    head = name.substring(0, ix);
                    name = name.substring(ix + 1);
                } else {
                    head = name;
                    name = "";
                }
                if (node.children == null) {
                    node.children = new HashMap<>();
                }
                LogNode child = node.children.get(head);
                if (child == null) {
                    child = new LogNode(node, this);
                    node.children.put(head, child);
                }
                node = child;
            }
            return node;
        }
    }

 //LoggerContext日志上下文信息包括：Hashtable namedLoggers和LogNode root;
    class LoggerContext {
        // Table of named Loggers that maps names to Loggers.
        private final Hashtable namedLoggers = new Hashtable<>();
        // Tree of named Loggers
        private final LogNode root;
        private LoggerContext() {
            this.root = new LogNode(null, this);
        }
        final LogManager getOwner() {
            return LogManager.this;
        }
        final Logger getRootLogger() {
            return getOwner().rootLogger;
        }
        synchronized Logger findLogger(String name) {
            // ensure that this context is properly initialized before looking for loggers.
            LoggerWeakRef ref = namedLoggers.get(name);
            if (ref == null) {
                return null;
            }
            Logger logger = ref.get();
            return logger;
        }
        synchronized void removeLoggerRef(String name, LoggerWeakRef ref) {
            namedLoggers.remove(name, ref);
        }
        synchronized Enumeration getLoggerNames() {
            return namedLoggers.keys();
        }
        LogNode getNode(String name) {
            if (name == null || name.equals("")) {
                return root;
            }
            LogNode node = root;
            while (name.length() > 0) {
                int ix = name.indexOf(".");
                String head;
                if (ix > 0) {
                    head = name.substring(0, ix);
                    name = name.substring(ix + 1);
                } else {
                    head = name;
                    name = "";
                }
                if (node.children == null) {
                    node.children = new HashMap<>();
                }
                LogNode child = node.children.get(head);
                if (child == null) {
                    child = new LogNode(node, this);
                    node.children.put(head, child);
                }
                node = child;
            }
            return node;
        }
    }

  //根日志类
    private final class RootLogger extends Logger {
        private RootLogger() {
            super("");
        }
        @Override
        public void log(LogRecord record) {
            initializeGlobalHandlers();
            super.log(record);
        }
        @Override
        public void addHandler(Handler h) {
            initializeGlobalHandlers();
            super.addHandler(h);
        }
        @Override
        public void removeHandler(Handler h) {
            initializeGlobalHandlers();
            super.removeHandler(h);
        }
        @Override
        Handler[] accessCheckedHandlers() {
            initializeGlobalHandlers();
            return super.accessCheckedHandlers();
        }
    }

//配置改变监听和配置改变事件
    private static class Beans {
        private static final Class propertyChangeListenerClass =
                getClass("java.beans.PropertyChangeListener");
        private static final Class propertyChangeEventClass =
                getClass("java.beans.PropertyChangeEvent");
        private static final Method propertyChangeMethod =
                getMethod(propertyChangeListenerClass,
                        "propertyChange",
                        propertyChangeEventClass);
        private static final Constructor propertyEventCtor =
                getConstructor(propertyChangeEventClass,
                        Object.class,
                        String.class,
                        Object.class,
                        Object.class);
        private static Class getClass(String name) {
            try {
                return Class.forName(name, true, Beans.class.getClassLoader());
            } catch (ClassNotFoundException e) {
                return null;
            }
        }
        private static Constructor getConstructor(Class c, Class... types) {
            try {
                return (c == null) ? null : c.getDeclaredConstructor(types);
            } catch (NoSuchMethodException x) {
                throw new AssertionError(x);
            }
        }
        private static Method getMethod(Class c, String name, Class... types) {
            try {
                return (c == null) ? null : c.getMethod(name, types);
            } catch (NoSuchMethodException e) {
                throw new AssertionError(e);
            }
        }
        /**
         * Returns {@code true} if java.beans is present.
         */
        static boolean isBeansPresent() {
            return propertyChangeListenerClass != null &&
                    propertyChangeEventClass != null;
        }
        static Object newPropertyChangeEvent(Object source, String prop,
                                             Object oldValue, Object newValue)
        {
            try {
                return propertyEventCtor.newInstance(source, prop, oldValue, newValue);
            } catch (InstantiationException | IllegalAccessException x) {
                throw new AssertionError(x);
            } catch (InvocationTargetException x) {
                Throwable cause = x.getCause();
                if (cause instanceof Error)
                    throw (Error)cause;
                if (cause instanceof RuntimeException)
                    throw (RuntimeException)cause;
                throw new AssertionError(x);
            }
        }

        static void invokePropertyChange(Object listener, Object ev) {
            try {
                propertyChangeMethod.invoke(listener, ev);
            } catch (IllegalAccessException x) {
                throw new AssertionError(x);
            } catch (InvocationTargetException x) {
                Throwable cause = x.getCause();
                if (cause instanceof Error)
                    throw (Error)cause;
                if (cause instanceof RuntimeException)
                    throw (RuntimeException)cause;
                throw new AssertionError(x);
            }
        }
    }

LogManager的核心方法：

 	public static LogManager getLogManager() {
        if (manager != null) {
            //确保初始化
            manager.ensureLogManagerInitialized();
        }
        return manager;
    }
   Logger demandLogger(String name, String resourceBundleName, Class caller) {
        Logger result = getLogger(name);
        if (result == null) {
            // only allocate the new logger once
            Logger newLogger = new Logger(name);
            do {
                if (addLogger(newLogger)) {
                    // We successfully added the new Logger that we
                    // created above so return it without refetching.
                    return newLogger;
                }
                result = getLogger(name);
            } while (result == null);
        }
        return result;
    }

//读取配置
    public void readConfiguration() throws IOException, SecurityException {
        checkPermission();
        // if a configuration class is specified, load it and use it.
        //加载日志配置类
        String cname = System.getProperty("java.util.logging.config.class");
        if (cname != null) {
            try {
                try {
                    Class clz = ClassLoader.getSystemClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                } catch (ClassNotFoundException ex) {
                    Class clz = Thread.currentThread().getContextClassLoader().loadClass(cname);
                    clz.newInstance();
                    return;
                }
            } catch (Exception ex) {
                System.err.println("Logging configuration class \"" + cname + "\" failed");
                System.err.println("" + ex);
                // keep going and useful config file.
            }
        }
        //加载日志配置文件
        String fname = System.getProperty("java.util.logging.config.file");
        if (fname == null) {
            fname = System.getProperty("java.home");
            if (fname == null) {
                throw new Error("Can't find java.home ??");
            }
            File f = new File(fname, "lib");
            f = new File(f, "logging.properties");
            fname = f.getCanonicalPath();//获取规范路径
        }
        try (final InputStream in = new FileInputStream(fname)) {
            final BufferedInputStream bin = new BufferedInputStream(in);
            readConfiguration(bin);
        }
    }
    //读取配置文件jre_home/logging.properties
    public void readConfiguration(InputStream ins) throws IOException, SecurityException {
        checkPermission();
        reset();//关闭原有handlers
        props.load(ins);
        // Instantiate new configuration objects.
        String names[] = parseClassNames("config");
        for (int i = 0; i < names.length; i++) {
            String word = names[i];
            try {
                Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
                clz.newInstance();
            } catch (Exception ex) {
                System.err.println("Can't load config class \"" + word + "\"");
                System.err.println("" + ex);
                // ex.printStackTrace();
            }
        }
        //给现有的日志设置最新的日志级别
        setLevelsOnExistingLoggers();
        Map listeners = null;
        synchronized (listenerMap) {
            if (!listenerMap.isEmpty())
                listeners = new HashMap<>(listenerMap);
        }
        if (listeners != null) {
            assert Beans.isBeansPresent();
            //修改配置的监听事件
            Object ev = Beans.newPropertyChangeEvent(LogManager.class, null, null, null);
            for (Map.Entry entry : listeners.entrySet()) {
                Object listener = entry.getKey();
                int count = entry.getValue().intValue();
                for (int i = 0; i < count; i++) {
                    Beans.invokePropertyChange(listener, ev);
                }
            }
        }
        // Note that we need to reinitialize global handles when they are first referenced.
        synchronized (this) {
            initializedGlobalHandlers = false;
        }
    }

	//------------------------------添加日志------------------------------
    public boolean addLogger(Logger logger) {
        final String name = logger.getName();
        if (name == null) {
            throw new NullPointerException();
        }
        loadLoggerHandlers(logger, name, name + ".handlers");
        return true;
    }
     //添加日志处理器
    private void loadLoggerHandlers(final Logger logger, final String name,
                                    final String handlersPropertyName)
    {
        AccessController.doPrivileged(new PrivilegedAction() {
            @Override
            public Object run() {
                String names[] = parseClassNames(handlersPropertyName);
                for (int i = 0; i < names.length; i++) {
                    String word = names[i];
                    try {
                        Class clz = ClassLoader.getSystemClassLoader().loadClass(word);
                        Handler hdl = (Handler) clz.newInstance();
                        String levs = getProperty(word + ".level");
                        if (levs != null) {
                            Level l = Level.findLevel(levs);
                            if (l != null) {
                                hdl.setLevel(l);
                            } else {
                                // Probably a bad level. Drop through.
                                System.err.println("Can't set level for " + word);
                            }
                        }
                        logger.addHandler(hdl);
                    } catch (Exception ex) {
                        System.err.println("Can't load log handler \"" + word + "\"");
                        System.err.println("" + ex);
                        ex.printStackTrace();
                    }
                }
                return null;
            }
        });
    }
 
  
LogManager类内容比较多，梳理起来比较麻烦。核心有几点：LoggerContext,LoggerWeakRef,LogNode内部类记录、维护日志信息。
 JUL中核心的类我们已经熟悉了，其中SimpleFormatter和StreamHandler相对简单不再赘述。
 
  
跑程序
 
  
API,源码都已经看过了，代码中不太明白的一定有不少，看完真是让人头大。不要方，下面才是重点，通过一个简单的HelloWorld程序将流程给捋顺了。
 
  
public class Test {
    public static void main(String[] args){
        Logger logger=Logger.getLogger("com.blue.Test");
        logger.log(Level.INFO,"MESSAGE:{0},{1}!",new Object[]{"HELLO","JUL"});
    }
}

 
  
运行结果：二月 15, 2019 4:59:19 下午 com.blue.Test main 信息: MESSAGE:HELLO,JUL!
 Java日志体系---JUL源码解析_第2张图片
 这样整个流程就很清晰了（更详细的代码追踪参考链接: https://pan.baidu.com/s/1Yxph2Y-yvwcs8D5p67kJAw 提取码: n9as）。
 
  
     
   
  • 示例中没有使用自定义的配置类和配置文件，采用JDK默认配置，路径jre/lib/logging.properties
     查看此文件：默认只使用java.util.logging.ConsoleHandler，
     而ConsoleHandler的默认级别为INFO，采用java.util.logging.SimpleFormatter，输出到System.err
    •  
  
 
  
   public ConsoleHandler() {
        sealed = false;
        configure();
        setOutputStream(System.err);
        sealed = true;
    }

 
  
造轮子
 
  
跑完程序，虽然逻辑会更加清晰，但还差点意思，我们需要更进一步——造个轮子。仿照JUL写一套日志实现（结合流程图和简化后的代码）。
 限于篇幅原因代码不在此处展示，如感兴趣请访问（百度网盘链接: https://pan.baidu.com/s/1Vlqcs8mZxrbijCa1Hp-AIw 提取码: 4m7p）或JUL的简单日志实现。
 注：①示例代码中配置文件读取部分可能需要调整
 ②如果封装成jar包时，读取jar内部的配置文件也有问题，建议将读取配置部分做适当修改。
 
  
货比三家
 
  
本文的重点是介绍JUL的源码学习，其他JAVA日志的信息只做简要介绍。
 
  
 
   
     
    
  • Jul (Java Util Logging),自Java1.4以来的官方日志实现。
    •  
    
  • Log4j Apache Log4j是一个基于Java的日志记录工具。它是由Ceki Gülcü首创的，现在则是Apache软件基金会的一个项目。 Log4j是几种Java日志框架之一。
    •  
    
  • Log4j 2 Apache Log4j 2是apache开发的一款Log4j的升级产品。
    •  
    
  • Logback 一套日志组件的实现(Slf4j阵营)。
    •  
    
  • Commons Logging Apache基金会所属的项目，是一套Java日志接口，之前叫Jakarta Commons Logging，后更名为Commons Logging。
    •  
    
  • Slf4j 类似于Commons Logging，是一套简易Java日志门面，本身并无日志的实现。（Simple Logging Facade for Java，缩写Slf4j）。
    •  
   
 
  
 
  
接口类日志框架：JCL，Slf4j
 日志实现框架：JUL，Log4j，Log4j2，Logback
 以上是常用的日志框架，相关的桥接包不再赘述。
 
  
买定离手
 
  
目前就性能而言Log4j2更胜一筹，其次是Logback。
 JUL和Log4j不推荐使用。
 目前本人对 Log4j2和Logback都只是限于简单配置使用，以后深入研究后会补充此部分的内容。
 
  
总结
 
  
第一次研究源码花费的时间还是比较长的，这篇文章断断续续写了两周。一直想研究Java源码，却不知从何开始，这次在学习日志知识的时候选择分析JUL的源码，收获还是很大的。限于篇幅和精力问题后面部分介绍的过于简单，想要深入了解的可以浏览下面的参考资料。
 整体来说JUL的核心是Logger类和LogManager类，其他都相对简单。
 
  
     
   
  • Logger包括Handler[]，LogManager，Level，Filter，name
    •  
   
  • LogManager包括Properties，LogContext
    •  
   
  • LogRecord包括 Level，message，loggerName，sourceMethodName，sourceClassName
    •  
   
  • Handler包括Filter，Formatter，Handler相关实现类
    •  
   
  • Filter主要是验证LogRecord:isLoggable(LogRecord record)
    •  
   
  • Formatter和相关实现类
    •  
   
  • Level包括name，value，定义的几个默认级别
    •  
  
 
  
简单的概括就是七个类（接口），两条线（获取Logger读取配置，记录日志并输出）。
 
  
参考资料
 
  
Spring Boot（十）Logback和Log4j2集成与日志发展史
 Log4j、Log4j 2、Logback、SFL4J、JUL、JCL的比较
 Asynchronous Loggers for Low-Latency Logging
 Java日志
 Java常用日志框架介绍
 Log日志规范
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • mysql主从数据同步
                                    林鹤霄
mysql主从数据同步
                                    
    配置mysql5.5主从服务器(转)   
教程开始：一、安装MySQL 
说明：在两台MySQL服务器192.168.21.169和192.168.21.168上分别进行如下操作，安装MySQL 5.5.22 
 二、配置MySQL主服务器（192.168.21.169）mysql  -uroot  -p   &nb
    
                                
    • 
                                
  • oracle学习笔记
                                    caoyong
oracle
                                    
    1、ORACLE的安装 
   a>、ORACLE的版本 
   8i,9i :   i是internet 
   10g,11g : grid (网格) 
   12c : cloud (云计算) 
   
   b>、10g不支持win7 
&
    
                                
    • 
                                
  • 数据库，SQL零基础入门
                                    天子之骄
sql数据库入门基本术语
                                    
    数据库，SQL零基础入门 
       做网站肯定离不开数据库，本人之前没怎么具体接触SQL，这几天起早贪黑得各种入门，恶补脑洞。一些具体的知识点，可以让小白不再迷茫的术语，拿来与大家分享。 
  
       数据库，永久数据的一个或多个大型结构化集合，通常与更新和查询数据的软件相关
    
                                
    • 
                                
  • pom.xml
                                    一炮送你回车库
pom.xml
                                    
    1、一级元素dependencies是可以被子项目继承的 
2、一级元素dependencyManagement是定义该项目群里jar包版本号的，通常和一级元素properties一起使用，既然有继承，也肯定有一级元素modules来定义子元素 
3、父项目里的一级元素<modules> 
<module>lcas-admin-war</module> 
<
    
                                
    • 
                                
  • sql查地区省市县
                                    3213213333332132
sqlmysql
                                    
    
-- db_yhm_city   
SELECT * FROM db_yhm_city WHERE class_parent_id = 1 -- 海南 class_id = 9 港、奥、台 class_id = 33、34、35   
  
SELECT * FROM db_yhm_city WHERE class_parent_id =169   
  
SELECT d1.cla
    
                                
    • 
                                
  • 关于监听器那些让人头疼的事
                                    宝剑锋梅花香
画图板监听器鼠标监听器
                                    
           本人初学JAVA，对于界面开发我只能说有点蛋疼，用JAVA来做界面的话确实需要一定的耐心（不使用插件，就算使用插件的话也没好多少）既然Java提供了界面开发，老师又要求做，只能硬着头皮上啦。但是监听器还真是个难懂的地方，我是上了几次课才略微搞懂了些。 
      
    
                                
    • 
                                
  • JAVA的遍历MAP
                                    darkranger
map
                                    
    Java Map遍历方式的选择 
1. 阐述 
　　对于Java中Map的遍历方式，很多文章都推荐使用entrySet，认为其比keySet的效率高很多。理由是：entrySet方法一次拿到所有key和value的集合；而keySet拿到的只是key的集合，针对每个key，都要去Map中额外查找一次value，从而降低了总体效率。那么实际情况如何呢？ 
　　为了解遍历性能的真实差距，包括在遍历ke
    
                                
    • 
                                
  • POJ 2312 Battle City 优先多列+bfs
                                    aijuans
搜索
                                    
    来源：http://poj.org/problem?id=2312 
题意：题目背景就是小时候玩的坦克大战，求从起点到终点最少需要多少步。已知S和R是不能走得，E是空的，可以走，B是砖，只有打掉后才可以通过。 
思路：很容易看出来这是一道广搜的题目，但是因为走E和走B所需要的时间不一样，因此不能用普通的队列存点。因为对于走B来说，要先打掉砖才能通过，所以我们可以理解为走B需要两步，而走E是指需要1
    
                                
    • 
                                
  • Hibernate与Jpa的关系，终于弄懂
                                    avords
javaHibernate数据库jpa
                                    
    我知道Jpa是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。 
在play中定义Model时，使用的是jpa的annotations，比如javax.persistence.Entity, Table, Column, OneToMany
    
                                
    • 
                                
  • 酸爽的console.log
                                    bee1314
console
                                    
    在前端的开发中，console.log那是开发必备啊，简直直观。通过写小函数，组合大功能。更容易测试。但是在打版本时，就要删除console.log，打完版本进入开发状态又要添加，真不够爽。重复劳动太多。所以可以做些简单地封装，方便开发和上线。 
/**
 * log.js hufeng
 * The safe wrapper for `console.xxx` functions
 *  
    
                                
    • 
                                
  • 哈佛教授：穷人和过于忙碌的人有一个共同思维特质
                                    bijian1013
时间管理励志人生穷人过于忙碌
                                    
            一个跨学科团队今年完成了一项对资源稀缺状况下人的思维方式的研究，结论是：穷人和过于忙碌的人有一个共同思维特质，即注意力被稀缺资源过分占据，引起认知和判断力的全面下降。这项研究是心理学、行为经济学和政策研究学者协作的典范。 
　　这个研究源于穆来纳森对自己拖延症的憎恨。他7岁从印度移民美国，很快就如鱼得水，哈佛毕业
    
                                
    • 
                                
  • other operate
                                    征客丶
OSosx
                                    
    一、Mac Finder 设置排序方式，预览栏 在显示－》查看显示选项中 
二、有时预览显示时，卡死在那，有可能是一些临时文件夹被删除了，如：/private/tmp[有待验证] 
 
-------------------------------------------------------------------- 
若有其他凝问或文中有错误，请及时向我指出， 
我好及时改正，同时也让我们一
    
                                
    • 
                                
  • 【Scala五】分析Spark源代码总结的Scala语法三
                                    bit1129
scala
                                    
    1. If语句作为表达式 
    val properties = if (jobIdToActiveJob.contains(jobId)) {
      jobIdToActiveJob(stage.jobId).properties
    } else {
      // this stage will be assigned to "default" po
    
                                
    • 
                                
  • ZooKeeper 入门
                                    BlueSkator
中间件zk
                                    
    ZooKeeper是一个高可用的分布式数据管理与系统协调框架。基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题。网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍。 
值得注意的是，ZK并非天生就是为这些应用场景设计的，都是后来众多开发者根据其框架的特性，利
    
                                
    • 
                                
  • MySQL取得当前时间的函数是什么 格式化日期的函数是什么
                                    BreakingBad
mysqlDate
                                    
    取得当前时间用 now() 就行。
在数据库中格式化时间 用DATE_FORMA T(date, format) .
根据格式串format 格式化日期或日期和时间值date，返回结果串。

  可用DATE_FORMAT( ) 来格式化DATE 或DATETIME 值，以便得到所希望的格式。根据format字符串格式化date值:

  %S, %s 两位数字形式的秒（ 00,01,
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-组合模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.util.ArrayList;
import java.util.List;

abstract class Component {
	
	public abstract void printStruct(Str
    
                                
    • 
                                
  • 4_JAVA+Oracle面试题(有答案)
                                    chenke
oracle
                                    
    基础测试题 
 卷面上不能出现任何的涂写文字，所有的答案要求写在答题纸上，考卷不得带走。 
选择题 
1、 What will happen when you attempt to compile and run the following code? （3） 
public class Static { 
 static { 
 int x = 5; // 在static内有效 
 } 
 st
    
                                
    • 
                                
  • 新一代工作流系统设计目标
                                    comsci
工作算法脚本
                                    
     
  用户只需要给工作流系统制定若干个需求，流程系统根据需求，并结合事先输入的组织机构和权限结构，调用若干算法，在流程展示版面上面显示出系统自动生成的流程图，然后由用户根据实际情况对该流程图进行微调，直到满意为止，流程在运行过程中，系统和用户可以根据情况对流程进行实时的调整，包括拓扑结构的调整，权限的调整，内置脚本的调整。。。。。 
 
 在这个设计中，最难的地方是系统根据什么来生成流
    
                                
    • 
                                
  • oracle 行链接与行迁移
                                    daizj
oracle行迁移
                                    
    表里的一行对于一个数据块太大的情况有二种(一行在一个数据块里放不下) 
 
第一种情况: 
INSERT的时候，INSERT时候行的大小就超一个块的大小。Oracle把这行的数据存储在一连串的数据块里(Oracle Stores the data for the row in a chain of data blocks)，这种情况称为行链接(Row Chain)，一般不可避免(除非使用更大的数据
    
                                
    • 
                                
  • [JShop]开源电子商务系统jshop的系统缓存实现
                                    dinguangx
jshop电子商务
                                    
    前言 
jeeshop中通过SystemManager管理了大量的缓存数据，来提升系统的性能，但这些缓存数据全部都是存放于内存中的，无法满足特定场景的数据更新（如集群环境）。JShop对jeeshop的缓存机制进行了扩展，提供CacheProvider来辅助SystemManager管理这些缓存数据，通过CacheProvider,可以把缓存存放在内存,ehcache,redis，memcache
    
                                
    • 
                                
  • 初三全学年难记忆单词
                                    dcj3sjt126com
englishword
                                    
    several 儿子；若干 
shelf 架子 
knowledge 知识；学问 
librarian 图书管理员 
abroad 到国外，在国外 
surf 冲浪 
wave 浪；波浪 
twice 两次；两倍 
describe 描写；叙述 
especially 特别；尤其 
attract 吸引 
prize 奖品；奖赏 
competition 比赛；竞争 
event 大事；事件 
O
    
                                
    • 
                                
  • sphinx实践
                                    dcj3sjt126com
sphinx
                                    
      
安装参考地址:http://briansnelson.com/How_to_install_Sphinx_on_Centos_Server 
  
yum install sphinx 
如果失败的话使用下面的方式安装 
wget http://sphinxsearch.com/files/sphinx-2.2.9-1.rhel6.x86_64.rpm 
yum loca
    
                                
    • 
                                
  • JPA之JPQL（三）
                                    frank1234
ormjpaJPQL
                                    
    1 什么是JPQL 
JPQL是Java Persistence Query Language的简称，可以看成是JPA中的HQL， JPQL支持各种复杂查询。 
 
2 检索单个对象 
@Test 
public  void querySingleObject1() { 
    Query query = em.createQuery("sele
    
                                
    • 
                                
  • Remove Duplicates from Sorted Array II
                                    hcx2013
remove
                                    
    Follow up for "Remove Duplicates":What if duplicates are allowed at most twice? 
For example,Given sorted array nums = [1,1,1,2,2,3], 
Your function should return length 
    
                                
    • 
                                
  • Spring4新特性——Groovy Bean定义DSL
                                    jinnianshilongnian
spring 4
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装Mysql5.5
                                    liuxingguome
centos
                                    
    CentOS下以RPM方式安装MySQL5.5 
 
首先卸载系统自带Mysql： 
yum remove mysql mysql-server mysql-libs compat-mysql51 
rm -rf /var/lib/mysql 
rm /etc/my.cnf 
查看是否还有mysql软件： 
rpm -qa|grep mysql 
 
 
 
去http://dev.mysql.c
    
                                
    • 
                                
  • 第14章 工具函数（下）
                                    onestopweb
函数
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • POJ 1050
                                    SaraWon
二维数组子矩阵最大和
                                    
    POJ ACM第1050题的详细描述，请参照 
http://acm.pku.edu.cn/JudgeOnline/problem?id=1050 
 
题目意思： 
给定包含有正负整型的二维数组，找出所有子矩阵的和的最大值。 
如二维数组 
0 -2 -7 0 
9 2 -6 2 
-4 1 -4 1 
-1 8 0 -2 
中和最大的子矩阵是 
9 2 
-4 1 
-1 8 
且最大和是15
    
                                
    • 
                                
  • [5]设计模式——单例模式
                                    tsface
java单例设计模式虚拟机
                                    
    单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点 
  
安全的单例模式： 
  
  
/*
 * @(#)Singleton.java  2014-8-1
 *
 * Copyright 2014 XXXX, Inc. All rights reserved.
 */
package com.fiberhome.singleton;


    
                                
    • 
                                
  • Java8全新打造，英语学习supertool
                                    yangshangchuan
javasuperword闭包java8函数式编程
                                    
    superword是一个Java实现的英文单词分析软件，主要研究英语单词音近形似转化规律、前缀后缀规律、词之间的相似性规律等等。Clean code、Fluent style、Java8 feature: Lambdas, Streams and Functional-style Programming。 
  
升学考试、工作求职、充电提高，都少不了英语的身影，英语对我们来说实在太重要
    
                                
    •