精华内容
下载资源
问答
  • Java swing组件介绍

    万次阅读 多人点赞 2018-07-29 14:58:47
    本文链接: ... Java Swing 图形界面开发(目录) 1. Swing简介 Swing 是 Java 为图形界面应用开发提供的一组工具包,是 Java 基础类的一部分。 Swing 包含了构建图...

    本文链接: http://blog.csdn.net/xietansheng/article/details/72814531

    Java Swing 图形界面开发(目录)

    1. Swing简介

    Swing 是 Java 为图形界面应用开发提供的一组工具包,是 Java 基础类的一部分。

    Swing 包含了构建图形界面(GUI)的各种组件,如: 窗口、标签、按钮、文本框等。

    Swing 提供了许多比 AWT 更好的屏幕显示元素,使用纯 Java 实现,能够更好的兼容跨平台运行。

    为了和 AWT 组件区分,Swing 组件在javax.swing.*包下,类名均以 J 开头,例如: JFrame、JLabel、JButton等。

    2. Swing组件

    一个 Java 的图形界面,由各种不同类型的“元素”组成,例如: 窗口、菜单栏、对话框、标签、按钮、文本框等等,这些“元素”统一被称为 组件Component)。

    组件按照不同的功能,可分为 顶层容器中间容器基本组件。一个简单窗口的组成,如下层级结构所示:

    • 顶层容器
      • 菜单栏
      • 中间容器
        • 基本组件
        • 基本组件

    组件类型的继承关系:

    • 顶层容器 属于窗口类组件,继承自java.awt.Window
    • 中间容器 和 基本组件 继承自javax.swing.JComponent

    (1)顶层容器

    顶层容器属于窗口类组件,可以独立显示,一个图形界面至少需要一个窗口,例如:

    #组件描述
    1JFrame一个普通的窗口(绝大多数 Swing 图形界面程序使用 JFrame 作为顶层容器)
    2JDialog对话框



    (2)中间容器

    中间容器充当基本组件的载体,不可独立显示。中间容器可以添加若干基本组件(也可以嵌套添加中间容器),对容器内的组件进行管理,类似于给各种复杂的组件进行分组管理。最顶层的一个中间容器必须依托在顶层容器(窗口)内。

    常用的中间容器(面板):

    #组件描述
    1JPanel一般轻量级面板容器组件
    2JScrollPane带滚动条的,可以水平和垂直滚动的面板组件
    3JSplitPane分隔面板
    4JTabbedPane选项卡面板
    5JLayeredPane层级面板



    特殊的中间容器:

    #组件描述
    1JMenuBar菜单栏
    2JToolBar工具栏
    3JPopupMenu弹出菜单
    4JInternalFrame内部窗口



    (3)基本组件

    基本组件是直接实现人机交互的组件。

    常用的简单的基本组件:

    #组件描述
    1JLabel标签
    2JButton按钮
    3JRadioButton单选按钮
    4JCheckBox复选框
    5JToggleButton开关按钮
    6JTextField文本框
    7JPasswordField密码框
    8JTextArea文本区域
    9JComboBox下拉列表框
    10JList列表
    11JProgressBar进度条
    12JSlider滑块



    选取器组件:

    #组件描述
    1JFileChooser文件选取器
    2JColorChooser颜色选取器



    其他较为复杂的基本组件:

    #组件描述
    1JTable表格
    2JTree

    3. 布局管理器

    Swing 的各种组件(JComponent)添加到面板容器中(JPanel),需要给面板容器指定布局管理器(LayoutManager),明确容器(Container)内的各个组件之间的排列布局方式。

    常用的布局管理器:

    #布局管理器描述
    1FlowLayout流式布局,按组件加入的顺序,按水平方向排列,排满一行换下一行继续排列。
    2GridLayout网格布局,把Container按指定行列数分隔出若干网格,每一个网格按顺序放置一个控件。
    3GridBagLayout网格袋布局,按网格划分Container,每个组件可占用一个或多个网格,可将组件垂直、水平或沿它们的基线对齐。
    4BoxLayout箱式布局,将Container中的多个组件按 水平 或 垂直 的方式排列。
    5GroupLayout分组布局,将组件按层次分组(串行 或 并行),分别确定 组件组 在 水平 和 垂直 方向上的位置。
    6CardLayout卡片布局,将Container中的每个组件看作一张卡片,一次只能显示一张卡片,默认显示第一张卡片。
    7BorderLayout边界布局,把Container按方位分为 5 个区域(东、西、南、北、中),每个区域放置一个组件。
    8SpringLayout弹性布局,通过定义组件四条边的坐标位置来实现布局。
    9null绝对布局,通过设置组件在Container中的坐标位置来放置组件。

    4. 代码实例: 一个简单的窗口程序

    package com.xiets.swing;
    
    import javax.swing.*;
    
    public class Main {
    
        public static void main(String[] args) {
            // 1. 创建一个顶层容器(窗口)
            JFrame jf = new JFrame("测试窗口");          // 创建窗口
            jf.setSize(250, 250);                       // 设置窗口大小
            jf.setLocationRelativeTo(null);             // 把窗口位置设置到屏幕中心
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 当点击窗口的关闭按钮时退出程序(没有这一句,程序不会退出)
    
            // 2. 创建中间容器(面板容器)
            JPanel panel = new JPanel();                // 创建面板容器,使用默认的布局管理器
    
            // 3. 创建一个基本组件(按钮),并添加到 面板容器 中
            JButton btn = new JButton("测试按钮");
            panel.add(btn);
    
            // 4. 把 面板容器 作为窗口的内容面板 设置到 窗口
            jf.setContentPane(panel);
    
            // 5. 显示窗口,前面创建的信息都在内存中,通过 jf.setVisible(true) 把内存中的窗口显示在屏幕上。
            jf.setVisible(true);
        }
    
    }
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    结果展示:

    result.png


            <link href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css" rel="stylesheet">
                </div>
    
    展开全文
  • 本文实例讲述了Android编程实现滑动开关组件功能。分享给大家供大家参考,具体如下: 由于Android并未提供滑动开关之类的组件,所以我们需要自己去实现一个自定义的视图组件来实现滑动开关效果。 这里有一个示例代码...
  • 史上最全Java各类日志组件分析汇总

    千次阅读 2017-12-08 12:03:51
    Java日志工具基本介绍在java的世界里有许多实现日志功能的工具,最早得到广泛使用的是 log4j,现在比较流行的是slf4j+logback。作为开发人员,我们有时候需要封装一些组件(二方包)提供给其他人员使用,但是那么多...

    Java日志工具

    基本介绍

    在java的世界里有许多实现日志功能的工具,最早得到广泛使用的是 log4j,现在比较流行的是slf4j+logback。作为开发人员,我们有时候需要封装一些组件(二方包)提供给其他人员使用,但是那么多的日志工具,根本没法保证每个组件里都能使用约定好的日志工具,况且还有很多第三方的包,鬼知道他会用什么日志工具。假如一个应用程序用到了两个组件,恰好两个组件使用不同的日志工具,那么应用程序就会有两份日志输出了,蛋疼吧。。

    下面简单介绍下常见的日志工具:

    • JUL

      JUL全称java.util.logging.Logger,JDK自带的日志系统,从JDK1.4就有了。因为log4j的存在,这个logger一直沉默着,其实在一些测试性的代码中,jdk自带的logger比log4j更方便。JUL是自带具体实现的,与log4j、logback等类似,而不是像JCL、slf4j那样的日志接口封装。

      import java.util.logging.Level;
      import java.util.logging.Logger;
      
      private static final Logger LOGGER = Logger.getLogger(MyClass.class.getName());
      • 相同名字的Logger对象全局只有一个;
      • 一般使用圆点分隔的层次命名空间来命名 Logger;Logger 名称可以是任意的字符串,但是它们一般应该基于被记录组件的包名或类名,如 java.net 或 javax.swing;
      • 配置文件默认使用jre/lib/logging.properties,日志级别默认为INFO;
      • 可以通过系统属性java.util.logging.config.file指定路径覆盖系统默认文件;
      • 日志级别由高到低依次为:SEVERE(严重)、WARNING(警告)、INFO(信息)、CONFIG(配置)、FINE(详细)、FINER(较详细)、FINEST(非常详细)。另外还有两个全局开关:OFF「关闭日志记录」和ALL「启用所有消息日志记录」。
      • 《logging.properties》文件中,默认日志级别可以通过.level= ALL来控制,也可以基于层次命名空间来控制,按照Logger名字进行前缀匹配,匹配度最高的优先采用;日志级别只认大写;
      • JUL通过handler来完成实际的日志输出,可以通过配置文件指定一个或者多个hanlder,多个handler之间使用逗号分隔;handler上也有一个日志级别,作为该handler可以接收的日志最低级别,低于该级别的日志,将不进行实际的输出;handler上可以绑定日志格式化器,比如java.util.logging.ConsoleHandler就是使用的String.format来支持的;

      配置文件示例:

      handlers= java.util.logging.ConsoleHandler
      
      .level= ALL
      com.suian.logger.jul.xxx.level = CONFIG
      com.suian.logger.jul.xxx.demo2.level = FINE
      com.suian.logger.jul.xxx.demo3.level = FINER
      
      java.util.logging.ConsoleHandler.level = ALL
      java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
      java.util.logging.SimpleFormatter.format=%1$tF %1$tT [%4$s] %3$s -  %5$s %n
    • Apache Commons Logging

      之前叫Jakarta Commons Logging,简称JCL,是Apache提供的一个通用日志API,可以让应用程序不再依赖于具体的日志实现工具。

      commons-logging包中对其它一些日志工具,包括Log4J、Avalon LogKit、JUL等,进行了简单的包装,可以让应用程序在运行时,直接将JCL API打点的日志适配到对应的日志实现工具中。

      common-logging通过动态查找的机制,在程序运行时自动找出真正使用的日志库。这一点与slf4j不同,slf4j是在编译时静态绑定真正的Log实现库。

      commons-logging包里的包装类和简单实现列举如下:

      • org.apache.commons.logging.impl.Jdk14Logger,适配JDK1.4里的JUL;
      • org.apache.commons.logging.impl.Log4JLogger,适配Log4J;
      • org.apache.commons.logging.impl.LogKitLogger,适配avalon-Logkit;
      • org.apache.commons.logging.impl.SimpleLog,common-logging自带日志实现类,它实现了Log接口,把日志消息都输出到系统错误流System.err中;
      • org.apache.commons.logging.impl.NoOpLog,common-logging自带日志实现类,它实现了Log接口,其输出日志的方法中不进行任何操作;

      如果只引入Apache Commons Logging,也没有通过配置文件《commons-logging.properties》进行适配器绑定,也没有通过系统属性或者SPI重新定义LogFactory实现,默认使用的就是jdk自带的java.util.logging.Logger来进行日志输出。

      JCL使用配置文件commons-logging.properties,可以在该文件中指定具体使用哪个日志工具。不配置的话,默认会使用JUL来输出日志。配置示例:

      org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger
    • Avalon LogKit

      Avalon LogKit是一个高速日志记录工具集,Avalon里的各个组件Framework、Excalibur、Cornerstone和Phoenix都用到它。它的模型与JDK 1.4 Logging package采用相同的原理,但与JDK 1.2+兼容。使用LogKit的原因是:Context和LogTargets。使用Log4j的时候,日志的内容只能是一句话,而使用LogKit,你可以记录很多项内容,甚至可以各项内容记录到对应的数据库字段中。如果使用Log4j存储日志到不同的存储介质,如数据库,需要使用Appender,而LogKit已经可以支持多种存储目标。

    • log4j

      Log4j是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、数据库等;我们也可以控制每一条日志的输出格式;通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。 Log4j有7种不同的log级别,按照等级从低到高依次为:TRACE、DEBUG、INFO、WARN、ERROR、FATAL、OFF。如果配置为OFF级别,表示关闭log。 Log4j支持两种格式的配置文件:properties和xml。包含三个主要的组件:Logger、appender、Layout。

    • SLF4J

      SLF4J全称The Simple Logging Facade for Java,简单日志门面,这个不是具体的日志解决方案,而是通过门面模式提供一些Java Logging API,类似于JCL。题外话,作者当时创建SLF4J的目的就是为了替代Jakarta Commons Logging(JCL)。 SLF4J提供的核心API是一些接口以及一个LoggerFactory的工厂类。在使用SLF4J的时候,不需要在代码中或配置文件中指定你打算使用哪个具体的日志系统,可以在部署的时候不修改任何配置即可接入一种日志实现方案,在编译时静态绑定真正的Log库。

      使用SLF4J时,如果你需要使用某一种日志实现,那么你必须选择正确的SLF4J的jar包的集合(各种桥接包)。SLF4J提供了统一的记录日志的接口,只要按照其提供的方法记录即可,最终日志的格式、记录级别、输出方式等通过具体日志系统的配置来实现,因此可以在应用中灵活切换日志系统。

      logback是slf4j-api的天然实现,不需要桥接包就可以使用。另外slf4j还封装了很多其他的桥接包,可以使用到其他的日志实现中,比如slf4j-log4j12,就可以使用log4j进行底层日志输出,再比如slf4j-jdk14,可以使用JUL进行日志输出。

    • Logback

      Logback,一个“可靠、通用、快速而又灵活的Java日志框架”。Logback当前分成三个模块:logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个改良版本,完整实现了SLF4J API。logback-access模块与Servlet容器集成提供通过Http来访问日志的功能。Logback依赖配置文件logback.xml,当然也支持groovy方式。Logback相比log4j,有很多很多的优点,网上一搜一大片,此处就不再赘述了。

    • Log4j2

      Log4j 2是log4j 1.x和logback的改进版,据说采用了一些新技术(无锁异步等等),使得日志的吞吐量、性能比log4j 1.x提高10倍,并解决了一些死锁的bug,而且配置更加简单灵活。

      Log4j2支持插件式结构,可以根据需要自行扩展Log4j2,实现自己的appender、logger、filter等。 在配置文件中可以引用属性,还可以直接替代或传递到组件,而且支持json格式的配置文件。不像其他的日志框架,它在重新配置的时候不会丢失之前的日志文件。 Log4j2利用Java5中的并发特性支持,尽可能地执行最低层次的加锁。解决了在log4j 1.x中存留的死锁的问题。 Log4j 2是基于LMAX Disruptor库的。在多线程的场景下,和已有的日志框架相比,异步logger拥有10倍左右的效率提升。

      Log4j2体系结构:
      这里写图片描述

    使用场景

    • 只使用java.util.logging.Logger

      最简单的场景,正式系统一般不会这么用,自己写点小demo、测试用例啥的是可以这么用。不要任何第三方依赖,jdk原生支持。

    • 只使用Apache Commons Logging

      需要引入commons-logging包,示例如下:

            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
    • Apache Commons Logging和log4j结合使用
      需要引入commons-logging包和log4j包,示例如下:

            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>

      该模式下可以使用的打点api:

      • org.apache.commons.logging.Log,commons-logging里的api;
      • org.apache.log4j.Logger,log4j里的api;

      无论使用哪种api打点,最终日志都会通过log4j进行实际的日志记录。推荐用commons-logging里的api,如果直接用log4j里的api,就跟单用log4j没区别,就没有再引入commons-logging包的必要了。

      既然最终是通过log4j实现日志记录,那么日志输出的level、target等也就是通过log4j的配置文件进行控制了。下面是一个log4j配置文件《log4j.properties》的简单示例:

      
      #log4j.rootLogger = error,console
      
      log4j.logger.com.suian.logtest = trace,console
      
      
      #输出源console输出到控制台
      
      log4j.appender.console = org.apache.log4j.ConsoleAppender
      log4j.appender.console.Target = System.out
      log4j.appender.console.layout = org.apache.log4j.PatternLayout
      log4j.appender.console.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss,SSS} [%t] %-5p %c - [log4j]%m%n

      既然是推荐使用commons-logging里的api打点,为了能找到log4j的日志实现,必须通过《commons-logging.properties》配置文件显式的确定关联,示例如下:

      org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4JLogger

      代码中使用JCL api进行日志打点,底层使用log4j进行日志输出。日志输出控制依托于log4j的配置文件,另外需要在commons-logging.properties配置文件中显式指定与log4j的绑定关系。

    • 单独使用log4j

      这个是早几年最最流行的用法了,现在因为log4j本身的问题以及新的日志框架的涌现,已经逐步退出历史舞台了。具体怎么用自己去百度吧。

    • SLF4J结合Logback

      当下最流行的用法,SLF4J为使用场景最广泛的日志门面,加上Logback的天然实现,简单、统一、快速。

      需要引入第三方依赖:

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.version}</version>
            </dependency>
    • 单独使用Log4j2

      Log4j2感觉就是SLF4J+Logback。log4j-api等价于SLF4J,log4j-core等价于Logback。

      需要引入第三方依赖:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-api</artifactId>
                <version>2.6.2</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.6.2</version>
            </dependency>

    冲突处理

    理论上各种日志输出方式是可以共存的,比如log4j和log4j2以及logback等,但是麻烦的是我们得维护多个配置文件,必须充分了解每个组件使用的是那种日志组件,然后进行对应的配置文件配置。

    如何解决呢?每一个想做通用日志解决方案的,都对兼容性问题进行了特殊处理。目前只有slf4j和log4j2提供了这样的整合机制,其他的基本都很弱。

    代码中可能使用的日志打点Api列举:

    • java.util.logging.Logger,jdk自带的;
    • org.apache.commons.logging.Log,commons-logging包里的api;
    • org.apache.log4j.Logger,log4j包里的api;
    • org.apache.logging.log4j.Logger,log4j2提供的api,在log4j-api包里;
    • org.slf4j.Logger,slf4j提供的api,在slf4j-api包里;

    上述打点方式,在一个应用中是有可能共存的,即使自己写的代码可以确保都使用同一类api,但是引入的第三方依赖里就可能各式各样了。该怎么处理呢?

    前面已经提过了,现在能够对各类冲突支持比较到位的就是slf4j和log4j2,他们都提供了很多的绑定器和桥接器。

    • 所谓的绑定器,也可以称之为适配器或者包装类,就是将特定api打点的日志绑定到具体日志实现组件来输出。比如JCL可以绑定到log4j输出,也可以绑定到JUL输出;再比如slf4j,可以通过logback输出,也可以绑定到log4j、log4j2、JUL等;
    • 所谓的桥接器就是一个假的日志实现工具,比如当你把 jcl-over-slf4j.jar 放到 CLASS_PATH 时,即使某个组件原本是通过 JCL 输出日志的,现在却会被 jcl-over-slf4j “骗到”SLF4J 里,然后 SLF4J 又会根据绑定器把日志交给具体的日志实现工具。

    slf4j整合日志输出

    • java.util.logging.Logger

      将JUL日志整合到slf4j统一输出,需要引入slf4j提供的依赖包:

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jul-to-slf4j</artifactId>
                <version>1.7.22</version>
            </dependency>

      只引入依赖并不能整合JUL日志,该包里只是提供了一个JUL的handler,仍旧需要通过JUL的配置文件进行配置,slf4j绑定器(如logback)上设置的日志级别等价于JUL handler上的日志级别,因此控制JUL的日志输出,日志级别仍旧分两个地方控制:JUL配置文件《logging.properties》和slf4j绑定器的配置文件,比如《logback.xml》、《log4j2.xml》等。

      • 建立jdk14-logger的配置文件《logger.properties》,加入handler配置以及日志级别配置;
      handlers= org.slf4j.bridge.SLF4JBridgeHandler
      .level= ALL
      • 在启动程序或容器的时候加入JVM参数配置-Djava.util.logging.config.file = /path/logger.properties;当然也可以使用编程方式进行处理,可以在main方法或者扩展容器的listener来作为系统初始化完成;此种方式有些场景下不如配置JVM参数来的彻底,比如想代理tomcat的系统输出日志,编程方式就搞不定了;
    • org.apache.commons.logging.Log

      将JCL日志整合到slf4j统一输出,需要引入slf4j提供的依赖包:

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jcl-over-slf4j</artifactId>
                <version>1.7.22</version>
            </dependency>

      jcl-over-slf4j包里所有类的根路径为org.apache.commons.logging,也有Log和LogFactory类,相当于以重写commons-logging包的代价来实现对JCL的桥接。Log与commons-logging包里的一模一样,LogFactory的实现,代码写死使用的是org.apache.commons.logging.impl.SLF4JLogFactory。commons-logging包里默认使用的是org.apache.commons.logging.impl.LogFactoryImpl。以这样的代价来实现桥接,可以实现无缝对接,不像JUL那样还得添加额外配置,但是有一个坏处就是需要处理类库冲突了。commons-logging包和jcl-over-slf4j包肯定是不能共存的,需要将commons-logging包在classpath里排掉。

      题外话,因为JCL本身就支持通过配置文件《commons-logging.properties》绑定适配器,所以个人感觉更倾向于封装一个适配器的方式来支持,就像commons-logging包里的org.apache.commons.logging.impl.Log4JLogger,这样更符合程序员的思维,明明白白。

      桥接包的命名也是很讲究的,覆写的这种,命名为xxx-over-slf4j,如本例的jcl-over-slf4j;纯桥接的,命名为xxx-to-slf4j,如文章前面提到的jul-to-slf4j。

    • org.apache.log4j.Logger

      将log4j日志整合到slf4j统一输出,需要引入slf4j提供的依赖包:

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>log4j-over-slf4j</artifactId>
                <version>1.7.22</version>
            </dependency>

      看桥接包的名字就知道了,log4j-over-slf4j肯定是覆写了log4j:log4j包,因此使用起来只需要引入依赖即可,不需要其他额外的配置。但是仍旧是要处理冲突的,log4j包和log4j-over-slf4j是不能共存的哦。

    • org.apache.logging.log4j.Logger

      将log4j2日志整合到slf4j统一输出,slf4j没有提供桥接包,但是log4j2提供了,原理是一样的,首先引入log4j2的桥接包:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-to-slf4j</artifactId>
                <version>2.6.2</version>
            </dependency>

      log4j2提供的依赖包有org.apache.logging.log4j:log4j-apiorg.apache.logging.log4j:log4j-core,其作用看包名就清楚了。log4j-core是log4j-api的标准实现,同样log4j-to-slf4j也是log4j-api的一个实现。

      log4j-to-slf4j用于将log4j2输出的日志桥接到slf4j进行实际的输出,作用上来讲,log4j-core和log4j-to-slf4j是不能共存的,因为会存在两个log4j2的实现。

      经测试,就测试结果分析,共存也是木有问题的,何解?log4j2加载provider的时候采用了优先级策略,即使找到多个也能决策出一个可用的provider来。在所有提供log4j2实现的依赖包中,都有一个META-INF/log4j-provider.properties配置文件,里面的FactoryPriority属性就是用来配置provider优先级的,幸运的是log4j-to-slf4j(15)的优先级是高于log4j-core(10)的,因此测试结果符合预期,log4j2的日志桥接到了slf4j中进行输出。

      同样,为确保系统的确定性,不会因为log4j2的provider决策策略变更导致问题,建议还是要在classpath里排掉log4j-core,log4j2也是推荐这么做的。

    log4j2整合日志输出

    • java.util.logging.Logger

      将JUL日志整合到log4j2统一输出,需要引入log4j2提供的依赖包:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-jul</artifactId>
                <version>2.6.2</version>
            </dependency>

      log4j2整合JUL日志的方式与slf4j不同,slf4j只是定义了一个handler,仍旧依赖JUL的配置文件;log4j2则直接继承重写了java.util.logging.LogManager。使用时,只需要通过系统属性java.util.logging.manager绑定重写后的LogManager(org.apache.logging.log4j.jul.LogManager)即可,感觉比slf4j的方式要简单不少。

    • org.apache.commons.logging.Log

      将JCL日志整合到log4j2统一输出,需要引入log4j2提供的依赖包:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-jcl</artifactId>
                <version>2.6.2</version>
            </dependency>

      基于log4j-jcl包整合JCL比较简单,只要把log4j-jcl包扔到classpath就可以了。看起来slf4j的整合方式优雅多了,底层原理是这样的:JCL的LogFactory在初始化的时候,查找LogFactory的具体实现,是分了几种场景的,简单描述如下:

      1. 首先根据系统属性org.apache.commons.logging.LogFactory查找LogFactory实现类;
      2. 如果找不到,则以SPI方式查找实现类,META-INF/services/org.apache.commons.logging.LogFactory;log4j-jcl就是以这种方式支撑的;此种方式必须确保整个应用中,包括应用依赖的第三方jar包中,org.apache.commons.logging.LogFactory文件只有一个,如果存在多个的话,哪个先被加载则以哪个为准。万一存在冲突的话,排查起来也挺麻烦的。
      3. 还找不到,则读取《commons-logging.properties》配置文件,使用org.apache.commons.logging.LogFactory属性指定的LogFactory实现类;
      4. 最后再找不到,就使用默认的实现org.apache.commons.logging.impl.LogFactoryImpl。
    • org.apache.log4j.Logger

      将log4j 1.x日志整合到log4j2统一输出,需要引入log4j2提供的依赖包:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-1.2-api</artifactId>
                <version>2.6.2</version>
            </dependency>

      log4j2里整合log4j 1.x日志,也是通过覆写log4j 1.x api的方式来实现的,跟slf4j的实现原理一致。因此也就存在类库冲突的问题,使用log4j-1.2-api的话,必须把classpath下所有log4j 1.x的包清理掉。

    • org.slf4j.Logger

      将slf4j日志整合到log4j2统一输出,需要引入log4j2提供的依赖包:

            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-slf4j-impl</artifactId>
                <version>2.6.2</version>
            </dependency>

      log4j-slf4j-impl基于log4j2实现了slf4j的接口,其就是slf4j-api和log4j2-core之间的一个桥梁。这里有个问题需要注意下,务必确保classpath下log4j-slf4j-impllog4j-to-slf4j不要共存,否则会导致事件无止尽地在SLF4J和Log4j2之间路由。

    日志打点API绑定实现

    slf4j-api和log4j-api都是接口,不提供具体实现,理论上基于这两种api输出的日志可以绑定到很多的日志实现上。slf4j和log4j2也确实提供了很多的绑定器。简单列举几种可能的绑定链:

    • slf4j → logback
    • slf4j → slf4j-log4j12 → log4j
    • slf4j → log4j-slf4j-impl → log4j2
    • slf4j → slf4j-jdk14 → jul
    • slf4j → slf4j-jcl → jcl
    • jcl → jul
    • jcl → log4j
    • log4j2-api → log4j2-core
    • log4j2-api → log4j-to-slf4j → slf4j

    来个环图:
    这里写图片描述

    展开全文
  • Vue开关 (Vue Switches) A Vue.js component for simple switches with theme support ... 一个Vue.js组件,用于简单的开关,具有对bulma,引导程序和自定义主题的主题支持。 安装 (Installation) npm install vu...

    Vue开关 (Vue Switches)

    A Vue.js component for simple switches with theme support for bulma, bootstrap and custom themes.

    一个Vue.js组件,用于简单的开关,具有对bulma,引导程序和自定义主题的主题支持。

    安装 (Installation)

    npm install vue-switches --save

    npm install vue-switches-保存

    现场演示 (Live Demo)

    http://drewjbartlett.com/demos/vue-switches/

    http://drewjbartlett.com/demos/vue-switches/

    翻译自: https://vuejsexamples.com/an-on-off-switch-component-for-vue-js-with-theme-support/

    展开全文
  • JavaSwing_2.5: JToggleButton(开关按钮)

    万次阅读 多人点赞 2017-07-08 23:21:59
    JToggleButton,开关按钮。JToggleButton 是 JRadioButton, JCheckBox 的父类,主要实现一个按钮的两种状态(选中 和 未选中)来实现开关切换的效果。

    本文链接: http://blog.csdn.net/xietansheng/article/details/74363501

    Java Swing 图形界面开发(目录)

    1. 概述

    官方JavaDocsApi: javax.swing.JToggleButton

    JToggleButton,开关按钮。JToggleButton 是 JRadioButton, JCheckBox 的父类,主要实现一个按钮的两种状态(选中 和 未选中)来实现开关切换的效果。

    JToggleButton 常用构造方法:

    // 无文本,默认未选中
    JToggleButton()
    
    // 有文本,默认未选中
    JToggleButton(String text)
    
    // 有文本,并指定是否选中
    JToggleButton(String text, boolean selected)
    

    JToggleButton 常用方法:

    // 设置开关按钮的 文本、字体 和 字体颜色
    void setText(String text)
    void setFont(Font font)
    void setForeground(Color fg)
    
    /* 以下方法定义在 javax.swing.AbstractButton 基类中 */
    
    // 设置开关按钮是否选中状态
    void setSelected(boolean b)
    
    // 判断开关按钮是否选中
    boolean isSelected()
    
    // 设置开关按钮是否可用
    void setEnabled(boolean enable)
    
    // 设置开关按钮在 默认(关)、被选中(开)、不可用 时显示的图片
    void setIcon(Icon defaultIcon)
    void setPressedIcon(Icon pressedIcon)
    void setDisabledIcon(Icon disabledIcon)
    
    // 设置图片和文本之间的间距
    void setIconTextGap(int iconTextGap)
    

    JToggleButton 常用监听器:

    // 添加状态改变监听器
    void addChangeListener(ChangeListener l)
    

    2. 代码实例: 默认的开关按钮

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.event.ChangeEvent;
    import javax.swing.event.ChangeListener;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setSize(250, 250);
            jf.setLocationRelativeTo(null);
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            JPanel panel = new JPanel();
    
            // 创建开关按钮
            JToggleButton toggleBtn = new JToggleButton("开关按钮");
    
            // 添加 toggleBtn 的状态被改变的监听
            toggleBtn.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    // 获取事件源(即开关按钮本身)
                    JToggleButton toggleBtn = (JToggleButton) e.getSource();
                    System.out.println(toggleBtn.getText() + " 是否选中: " + toggleBtn.isSelected());
                }
            });
    
            panel.add(toggleBtn);
    
            jf.setContentPane(panel);
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result_01.gif

    运行代码,点击开关按钮,查看控制台输出。

    3. 代码实例: 自定义图片开关

    使用下面两个图片分别代表开关按钮的 选中(开) 和 未选中(关) 状态,分别命名为: toggle_on.pngtoggle_off.png:

    toggle_on.png

    toggle_off.png

    package com.xiets.swing;
    
    import javax.swing.*;
    import javax.swing.event.ChangeEvent;
    import javax.swing.event.ChangeListener;
    
    public class Main {
    
        public static void main(String[] args) {
            JFrame jf = new JFrame("测试窗口");
            jf.setSize(250, 250);
            jf.setLocationRelativeTo(null);
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            JPanel panel = new JPanel();
    
            // 创建开关按钮
            JToggleButton toggleBtn = new JToggleButton();
    
            // 首先设置不绘制按钮边框
            toggleBtn.setBorderPainted(false);
    
            // 设置 选中(开) 和 未选中(关) 时显示的图片
            toggleBtn.setSelectedIcon(new ImageIcon("toggle_on.png"));
            toggleBtn.setIcon(new ImageIcon("toggle_off.png"));
    
            // 添加 toggleBtn 的状态被改变的监听
            toggleBtn.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    // 获取事件源(即开关按钮本身)
                    JToggleButton toggleBtn = (JToggleButton) e.getSource();
                    System.out.println(toggleBtn.getText() + " 是否选中: " + toggleBtn.isSelected());
                }
            });
    
            panel.add(toggleBtn);
    
            jf.setContentPane(panel);
            jf.setVisible(true);
        }
    
    }
    

    结果展示:

    result_02.gif

    运行代码,点击开关按钮,查看控制台输出。


    展开全文
  • 开关组件(Switch)

    千次阅读 2012-06-05 14:23:20
    1. Switch组件介绍   2. 使用Switch组件   3. 实例代码       1. Switch组件介绍   它是由API 14(Android 4.0, 4.0.1, 4.0.2)引入的新组建,是一种“组合按钮”,即继承了CompoundButton。就像...
  • JAVA编写计算器

    千次阅读 多人点赞 2019-05-23 22:32:02
    JAVA编写一个实现加减乘除运算的计算器 1.实现加减乘除以及乘方运算; 2.C是清除键,清除之前输入所有数据,计算结果归零。 3.CE也是清除键,清除上一个输入的数据。 思路就是创建一个窗口,然后给窗口添加容器或...
  • MyBatis面试题(2020最新版)

    万次阅读 多人点赞 2019-09-24 16:40:33
    整理好的MyBatis面试题库,史上最全的MyBatis面试题,MyBatis面试宝典,特此分享给大家 MyBatis 介绍 MyBatis 是一款优秀的...MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO(Plai...
  • 当我们搭建好图形界面窗体的时候,需要向窗体中加入各种组件,便于用户操作,用户在窗体中都会有哪些...综上,一个窗体中有多个组件组件有文本组件,按钮组件,标签组件和列表组件。当然了,一个窗体中有组件是...
  • java日志组件

    千次阅读 2013-10-17 14:48:45
    1.Log4j(log for java)是Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等。 2.通过定义每...
  • 火山安卓组件开关开关按钮开关:二、设置尺寸三、添加标题五、修改提示内容六、添加背景图 开关: 一、布局 按下图布局 二、设置尺寸 ①设置 ②效果 三、添加标题 ①设置 ②效果 ##四、添加背景图 ①设置 ...
  • 日志组件之debug动态开关

    千次阅读 2017-04-28 12:19:45
    日志组件之debug动态开关 一、应用场景 二、logback简介 三、logback应用debug动态开关   一、应用场景 生产环境,系统日志记录级别一般高于或等于INFO,不会开启DEBUG级别的日志打印。 ...
  • Android之实现滑动开关组件

    千次阅读 2014-12-15 13:24:52
     这里有一个示例代码,它包括三个类:开关组件视图、状态监听接口、MainActivity  我们先来看看整个demo的效果图:  我们先来看看视图组件的完整代码,代码都已经注释: package com.bear.swtichbuttondemo; ...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
     版本支持:系统中的组件或动态联接库可能要升级,由于这些组件或动态联接库都要在注册表中注册,由此可能带来一系列问题,例如,安装新程序时自动安装新组件替换旧组件,有可能使某些必须使用旧组件才可以运行的...
  • 1、开关按钮绘制 原理: 对绘制的图像面板添加鼠标点击事件,每点击一次,切换一次显示状态 2、布局(自定义布局...........) MyFrame: package Swing0501; import java.awt.BorderLayout; import java...
  • 逻辑组件 LogisimComponents 是一个扩展默认组件的库。 组件 转变 实现在鼠标释放时保持其状态的开关(与按钮不同)。 安装 从下载。 请按照以下说明操作。
  • java swing程序添加背景音乐或音效

    千次阅读 2020-10-29 09:00:02
    “在平时做小程序中我们可能会想在程序中加上一些...import java.io.IOException; import java.io.InputStream; public class MusicTest { private static Clip bgm;//背景乐 private static Clip hit;//音效 pr
  • 有swing组件简介知道Swing 是 Java 为图形界面应用开发提供的一组工具包,是 Java 基础类的一部分。 基本组件如下: JLabel(标签) JButton(按钮) JRadioButton(单选按钮) JCheckBox(复选框) JToggleB...
  • Android 开关控件Switch

    千次阅读 2020-07-13 17:01:15
    目录: 1.应用场景与概述 2.常用属性 3.简单使用 4.更改默认Switch的样式 5.自定义Switch ...开关控件,对低版本的有了更好的的支持。其实switch的应用场景和ToggleButton类似,多应用于两种状态的切换。 2...
  • JAVA学习笔记(四十九)- Swing相关组件

    千次阅读 2015-04-04 08:34:09
    JFrame组件import java.awt.Color;import javax.swing.JFrame; import javax.swing.JPanel;/* * Swing是在AWT基础上的扩展 * javax.swing包及其扩展包,组件的命名多以J开关 * * JFrame组件 */ public class ...
  • java,applet 容器、组件和布局管理器

    千次阅读 2012-09-17 09:26:38
     卡片布局(Card Layout)把每个组件看作一张卡片,好像一副扑克牌,它们叠在一起,每次只有最外面的一个组件可以被看到。  package sample;  import java.awt.*;  import java.awt.event.*;  ...
  • pfSense 规则开关组件 编写此组件以打开(启用)或关闭(禁用)pfSense 防火墙规则。 我的一个问题是为什么世界上会有人想要从 HA 做到这一点。 简而言之,我的孩子有时会拒绝打扫房间,并且需要在飞行中而不是在...
  • 组件化相信大家都很清楚他是什么,Android的一种开发架构,并且备受团队推崇,确实组件化在我看来对团队协作方面是帮助巨大的,随着应用开发的业务不断累积,我觉得我们更加应该关注架构的搭建,而不是一味的实现...
  • 如何在java中插入音乐

    万次阅读 多人点赞 2018-04-14 14:20:07
    下面是我在java中插入背景音乐的一些学习心得,在此向大家做一下分享。我使用的JDK版本是1.8版本。以我做的登陆界面为例在java中插入背景音乐我给出两种方法:第一种方法:新建一个Music类[java] view plain copy...
  • 日志是应用软件中不可缺少的部分,Apache的开源项目Log4j是一个功能强大的日志组件,提供方便的日志记录。在apache网站:jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。 一、入门实例 本例子...
  • Java GUI——Java图形用户界面

    多人点赞 2021-09-21 23:40:00
    Java GUI——Java图形用户界面 1、Java GUI概述 1.1、GUI的前世今生 早期,电脑向用户提供的是单调、枯燥、纯字符状态的“命令行界面(CLI)”。如:Windows中的DOS窗口。后来,Apple公司率先在电脑的操作系统中...
  • java--AWT组件

    千次阅读 2013-10-02 08:53:58
     按钮是最常用的一个组件,其构造方法是:Button b = new Button("Quit");  当按钮被点击后,会产生ActionEvent事件,需ActionListener接口进行监听和处理事件。  ActionEvent的对象调用getActionCommand()...
  • Java语法糖

    万次阅读 多人点赞 2019-08-27 16:50:13
    很多人说Java是一个“低糖语言”,其实从Java 7开始,Java语言层面上一直在添加各种糖,主要是在“Project Coin”项目下研发。尽管现在Java有人还是认为现在的Java是低糖,未来还会持续向着“高糖”的方向发展。 ...
  • 初学Java之AAWT组件

    2015-06-14 19:31:41
     按钮是最常用的一个组件,其构造方法是:Button b = new Button("Quit");   当按钮被点击后,会产生ActionEvent事件,需ActionListener接口进行监听和处理事件。  ActionEvent的对象调用getActionCommand()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,758
精华内容 9,503
关键字:

java开关组件

java 订阅