标签 Java 下的文章

外部库填补了 Java 核心库中的一些功能空白。

 title=

Java 自带有一组核心库,其中包含了定义常用数据类型和相关行为的库(例如 StringDate)、与主机操作系统交互的实用程序(例如 SystemFile),以及一些用来管理安全性、处理网络通信、创建或解析 XML的有用的子系统。鉴于核心库的丰富性,程序员通常很容易在其中找到有用的组件,以减少需要编写的代码量。

即便如此,核心库仍有一些功能上的不足,因此发现这些不足的程序员们还额外创建了很多有趣的 Java 库。例如,Apache Commons“是一个专注于可重用 Java 组件所有方面的 Apache 项目”,提供了大约 43 个开源库的集合(截至撰写本文时),涵盖了 Java 核心库之外的一系列功能 (例如 geometrystatistics),并增强或替换了 Java 核心库中的原有功能(例如 mathnumbers)。

另一种常见的 Java 库类型是系统组件的接口(例如数据库系统接口),本文会着眼于使用此类接口连接到 PostgreSQL 数据库,并得到一些有趣的信息。首先,我们来回顾一下库的重要部分。

什么是库?

library 里自然包含的是一些有用的代码。但为了发挥用处,代码需要以特定方式进行组织,特定的方式使 Java 程序员可以访问其中组件来解决手头问题。

可以说,一个库最重要的部分是它的应用程序编程接口(API)文档。这种文档很多人都熟悉,通常是由 Javadoc 生成的。Javadoc 读取代码中的结构化注释并以 HTML 格式输出文档,通常 API 的 package 在页面左上角的面板中显示, class 在左下角显示,同时右侧会有库、包或类级别的详细文档(具体取决于在主面板中选择的内容)。例如,Apache Commons Math 的顶级 API 文档 如下所示:

 title=

单击主面板中的包会显示该包中定义的 Java 类和接口。例如,org.apache.commons.math4.analysis.solvers 显示了诸如 BisectionSolver 这样的类,该类用于使用二分算法查找单变量实函数的零点。单击 BisectionSolver 链接会列出 BisectionSolver 类的所有方法。

这类文档可用作参考文档,不适合作为学习如何使用库的教程。比如,如果你知道什么是单变量实函数并查看包 org.apache.commons.math4.analysis.function,就可以试着使用该包来组合函数定义,然后使用 org.apache.commons.math4.analysis.solvers 包来查找刚刚创建的函数的零点。但如果你不知道,就可能需要更多学习向的文档,也许甚至是一个实际例子,来读懂参考文档。

这种文档结构还有助于阐明 package (相关 Java 类和接口定义的集合)的含义,并显示特定库中捆绑了哪些包。

这种库的代码通常是在 .jar 文件) 中,它基本上是由 Java 的 jar 命令创建的 .zip 文件,其中还包含一些其他有用的信息。.jar 文件通常被创建为构建过程的端点,该构建过程编译了所定义包中的所有 .java 文件。

要访问外部库提供的功能,有两个主要步骤:

  1. 确保通过类路径(或者命令行中的 -cp 参数或者 CLASSPATH 环境变量),库可用于 Java 编译步骤(javac)和执行步骤(java)。
  2. 使用恰当的 import 语句访问程序源代码中的包和类。

其余的步骤就与使用 String 等 Java核心类相同,使用库提供的类和接口定义来编写代码。很简单对吧?不过也没那么简单。首先,你需要了解库组件的预期使用模式,然后才能编写代码。

示例:连接 PostgreSQL 数据库

在数据库系统中访问数据的典型使用步骤是:

  1. 访问正在使用的特定数据库软件代码。
  2. 连接到数据库服务器。
  3. 构建查询字符串。
  4. 执行查询字符串。
  5. 针对返回的结果,做需要的处理。
  6. 断开与数据库服务器的连接。

所有这些面向程序员的部分由接口包 java.sql 提供,它独立于数据库,定义了核心客户端 Java 数据库连接(JDBC)API。java.sql 包是 Java 核心库的一部分,因此无需提供 .jar 文件即可编译。但每个数据库提供者都会创建自己的 java.sql 接口实现(例如 Connection 接口),并且必须在运行步骤中提供这些实现。

接下来我们使用 PostgreSQL,看看这一过程是如何进行的。

访问特定数据库的代码

以下代码使用 Java 类加载器Class.forName() 调用)将 PostgreSQL 驱动程序代码加载到正在执行的虚拟机中:

import java.sql.*;

public class Test1 {

    public static void main(String args[]) {

        // Load the driver (jar file must be on class path) [1]

        try {
            Class.forName("org.postgresql.Driver");
            System.out.println("driver loaded");
        } catch (Exception e1) {
            System.err.println("couldn't find driver");
            System.err.println(e1);
            System.exit(1);
        }

        // If we get here all is OK

        System.out.println("done.");
    }
}

因为类加载器可能失败,失败时会抛出异常,所以将对 Class.forName() 的调用放在 try-catch 代码块中。

如果你使用 javac 编译上面的代码,然后用 java 运行,会报异常:

me@mymachine:~/Test$ javac Test1.java
me@mymachine:~/Test$ java Test1
couldn't find driver
java.lang.ClassNotFoundException: org.postgresql.Driver
me@mymachine:~/Test$

类加载器要求类路径中有包含 PostgreSQL JDBC 驱动程序实现的 .jar 文件:

me@mymachine:~/Test$ java -cp ~/src/postgresql-42.2.5.jar:. Test1
driver loaded
done.
me@mymachine:~/Test$

连接到数据库服务器

以下代码实现了加载 JDBC 驱动程序和创建到 PostgreSQL 数据库的连接:

import java.sql.*;

public class Test2 {

        public static void main(String args[]) {

                // Load the driver (jar file must be on class path) [1]

                try {
                        Class.forName("org.postgresql.Driver");
                        System.out.println("driver loaded");
                } catch (Exception e1) {
                        System.err.println("couldn't find driver");
                        System.err.println(e1);
                        System.exit(1);
                }

                // Set up connection properties [2]

                java.util.Properties props = new java.util.Properties();
                props.setProperty("user","me");
                props.setProperty("password","mypassword");
                String database = "jdbc:postgresql://myhost.org:5432/test";

                // Open the connection to the database [3]

                try (Connection conn = DriverManager.getConnection(database, props)) {
                        System.out.println("connection created");
                } catch (Exception e2) {
                        System.err.println("sql operations failed");
                        System.err.println(e2);
                        System.exit(2);
                }
                System.out.println("connection closed");

                // If we get here all is OK

                System.out.println("done.");
        }
}

编译并运行上述代码:

me@mymachine:~/Test$ javac Test2.java
me@mymachine:~/Test$ java -cp ~/src/postgresql-42.2.5.jar:. Test2
driver loaded
connection created
connection closed
done.
me@mymachine:~/Test$

关于上述的一些注意事项:

  • 注释 [2] 后面的代码使用系统属性来设置连接参数(在本例中参数为 PostgreSQL 用户名和密码)。代码也可以从 Java 命令行获取这些参数并将所有参数作为参数包传递,同时还有一些其他 Driver.getConnection() 选项可用于单独传递参数。
  • JDBC 需要一个用于定义数据库的 URL,它在上述代码中被声明为 String database 并与连接参数一起传递给 Driver.getConnection() 方法。
  • 代码使用 try-with-resources 语句,它会在 try-catch 块中的代码完成后自动关闭连接。Stack Overflow 上对这种方法进行了长期的讨论。
  • try-with-resources 语句提供对 Connection 实例的访问,并可以在其中执行 SQL 语句;所有错误都会被同一个 catch 语句捕获。

用数据库的连接处理一些有趣的事情

日常工作中,我经常需要知道为给定的数据库服务器实例定义了哪些用户,这里我使用这个 简便的 SQL 来获取所有用户的列表:

import java.sql.*;

public class Test3 {

        public static void main(String args[]) {

                // Load the driver (jar file must be on class path) [1]

                try {
                        Class.forName("org.postgresql.Driver");
                        System.out.println("driver loaded");
                } catch (Exception e1) {
                        System.err.println("couldn't find driver");
                        System.err.println(e1);
                        System.exit(1);
                }

                // Set up connection properties [2]

                java.util.Properties props = new java.util.Properties();
                props.setProperty("user","me");
                props.setProperty("password","mypassword");
                String database = "jdbc:postgresql://myhost.org:5432/test";

                // Open the connection to the database [3]

                try (Connection conn = DriverManager.getConnection(database, props)) {
                        System.out.println("connection created");

                        // Create the SQL command string [4]

                        String qs = "SELECT " +
                                "       u.usename AS \"User name\", " +
                                "       u.usesysid AS \"User ID\", " +
                                "       CASE " +
                                "       WHEN u.usesuper AND u.usecreatedb THEN " +
                                "               CAST('superuser, create database' AS pg_catalog.text) " +
                        "       WHEN u.usesuper THEN " +
                                "               CAST('superuser' AS pg_catalog.text) " +
                                "       WHEN u.usecreatedb THEN " +
                                "               CAST('create database' AS pg_catalog.text) " +
                                "       ELSE " +
                                "               CAST('' AS pg_catalog.text) " +
                                "       END AS \"Attributes\" " +
                                "FROM pg_catalog.pg_user u " +
                                "ORDER BY 1";

                        // Use the connection to create a statement, execute it,
                        // analyze the results and close the result set [5]

                        Statement stat = conn.createStatement();
                        ResultSet rs = stat.executeQuery(qs);
                        System.out.println("User name;User ID;Attributes");
                        while (rs.next()) {
                                System.out.println(rs.getString("User name") + ";" +
                                                rs.getLong("User ID") + ";" +
                                                rs.getString("Attributes"));
                        }
                        rs.close();
                        stat.close();
               
                } catch (Exception e2) {
                        System.err.println("connecting failed");
                        System.err.println(e2);
                        System.exit(1);
                }
                System.out.println("connection closed");

                // If we get here all is OK

                System.out.println("done.");
        }
}

在上述代码中,一旦有了 Connection 实例,它就会定义一个查询字符串(上面的注释 [4]),创建一个 Statement 实例并用其来执行查询字符串,然后将其结果放入一个 ResultSet 实例。程序可以遍历该 ResultSet 实例来分析返回的结果,并以关闭 ResultSetStatement 实例结束(上面的注释 [5])。

编译和执行程序会产生以下输出:

me@mymachine:~/Test$ javac Test3.java
me@mymachine:~/Test$ java -cp ~/src/postgresql-42.2.5.jar:. Test3
driver loaded
connection created
User name;User ID;Attributes
fwa;16395;superuser
vax;197772;
mbe;290995;
aca;169248;
connection closed
done.
me@mymachine:~/Test$

这是在一个简单的 Java 应用程序中使用 PostgreSQL JDBC 库的(非常简单的)示例。要注意的是,由于 java.sql 库的设计方式,它不需要在代码中使用像 import org.postgresql.jdbc.*; 这样的 Java 导入语句,而是使用 Java 类加载器在运行时引入 PostgreSQL 代码的方式,也正因此无需在代码编译时指定类路径。


via: https://opensource.com/article/20/2/external-libraries-java

作者:Chris Hermansen 选题:lujun9972 译者:unigeorge 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

fastjar、gjar 和 jar 等工具可以帮助你手动或以编程方式构建 JAR 文件,而其他工具链,如 Maven 和 Gradle 提供了依赖性管理的功能。

 title=

根据我的经验,Java 的许多优点之一是它能够以整齐方便的包(称为 JAR,或 Java 归档)来提供应用程序。JAR 文件使用户很容易下载并启动他们想尝试的应用,很容易将该应用从一台计算机转移到另一台计算机(而且 Java 是跨平台的,所以可以鼓励自由分享),而且对于新的程序员来说,查看 JAR 文件的内容,以找出使 Java 应用运行的原因是很容易理解的。

创建 JAR 文件的方法有很多,包括 Maven 和 Gradle 等工具链解决方案,以及 IDE 中的一键构建功能。然而,也有一些独立的命令,如 jarfastgjar 和普通的 jar,它们对于快速和简单的构建是很有用的,并且可以演示 JAR 文件运行所需要的东西。

安装

在 Linux 上,你可能已经有了 fastjargjar 或作为 OpenJDK 包或 GCJ(GCC-Java)的一部分的 jar 命令。你可以通过输入不带参数的命令来测试这些命令是否已经安装:

$ fastjar
Try 'fastjar --help' for more information.
$ gjar
jar: must specify one of -t, -c, -u, -x, or -i
jar: Try 'jar --help' for more information
$ jar
Usage: jar [OPTION...] [ [--release VERSION] [-C dir] files] ...
Try `jar --help' for more information.

我安装了所有这些命令,但你只需要一个。所有这些命令都能够构建一个 JAR。

在 Fedora 等现代 Linux 系统上,输入一个缺失的命令你的操作系统提示安装它。

另外,你可以直接从 AdoptOpenJDK.net 为 Linux、MacOS 和 Windows 安装 Java

构建 JAR

首先,你需要构建一个 Java 应用。

为了简单起见,在一个名为 hello.java 的文件中创建一个基本的 “hello world” 应用:

class Main {
public static void main(String[] args) {
    System.out.println("Hello Java World");
}}

这是一个简单的应用,在某种程度上淡化了管理外部依赖关系在现实世界中的重要性。不过,这也足以让你开始了解创建 JAR 所需的基本概念了。

接下来,创建一个清单文件。清单文件描述了 JAR 的 Java 环境。在这个例子里,最重要的信息是识别主类,这样执行 JAR 的 Java 运行时就知道在哪里可以找到应用的入口点。

$ mdir META-INF
$ echo "Main-Class: Main" > META-INF/MANIFEST.MF

编译 Java 字节码

接下来,把你的 Java 文件编译成 Java 字节码。

$ javac hello.java

另外,你也可以使用 GCC 的 Java 组件来编译:

$ gcj -C hello.java

无论哪种方式,都会产生文件 Main.class

$ file Main.class
Main.class: compiled Java class data, version XX.Y

创建 JAR

你有了所有需要的组件,这样你就可以创建 JAR 文件了。

我经常包含 Java 源码给好奇的用户参考,这只需 META-INF 目录和类文件即可。

fastjar 命令使用类似于 tar 命令的语法。

$ fastjar cvf hello.jar META-INF Main.class

另外,你也可以用 gjar,方法大致相同,只是 gjar 需要你明确指定清单文件:

$ gjar cvf world.jar Main.class -m META-INF/MANIFEST.MF

或者你可以使用 jar 命令。注意这个命令不需要清单文件,因为它会自动为你生成一个,但为了安全起见,我明确定义了主类:

$ jar --create --file hello.jar --main-class=Main Main.class

测试你的应用:

$ java -jar hello.jar
Hello Java World

轻松打包

fastjargjarjar 这样的工具可以帮助你手动或以编程方式构建 JAR 文件,而其他工具链如 Maven 和 Gradle 则提供了依赖性管理的功能。一个好的 IDE 可能会集成这些功能中的一个或多个。

无论你使用什么解决方案,Java 都为分发你的应用代码提供了一个简单而统一的目标。


via: https://opensource.com/article/21/8/fastjar

作者:Seth Kenlon 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

让用户用命令行选项调整你的 Java 应用程序运行方式。

 title=

通常向终端中输入命令时,无论是启动 GUI 应用程序还是仅启动终端应用程序,都可以使用 命令行选项 options or switches or flags 以下简称选项)来修改应用程序的运行方式。这是 POSIX 规范 设定的标准,因此能够检测和解析选项对 Java 程序员而言是很有用的技能。

Java 中有若干种解析选项的方法,其中我最喜欢用的是 Apache Commons CLI 库,简称 commons-cli

安装 commons-cli

如果你使用类似 Maven 之类的项目管理系统以及 集成开发环境 Integrated Development Environment (简称 IDE),可以在项目属性(比如 pom.xml 配置文件或者 Eclipse 和 NetBeans 的配置选项卡)中安装 Apache Commons CLI 库。

而如果你采用手动方式管理库,则可以从 Apache 网站下载 该库的最新版本。下载到本地的是几个捆绑在一起的 JAR 文件,你只需要其中的一个文件 commons-cli-X.Y.jar(其中 X 和 Y 代指最新版本号)。把这个 JAR 文件或手动或使用 IDE 添加到项目,就可以在代码中使用了。

将库导入至 Java 代码

在使用 commons-cli 库之前,必须首先导入它。对于本次选项解析的简单示例而言,可以先在 Main.java 文件中简单写入以下标准代码:

package com.opensource.myoptparser;

import org.apache.commons.cli.*;

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

至此在 Java 中解析选项的准备工作已经做好了。

在 Java 中定义布尔选项

要实现解析选项,首先要定义应用程序可接收的有效选项。使用 Option(注意是单数)类来创建选项对象,使用 Options(注意是复数)类来追踪项目中创建的所有选项。

首先为选项创建一个组,按照惯例命名为 options

    //code
    Options options = new Options();

接下来,通过列出短选项(即选项名简写)、长选项(即全写)、默认布尔值(LCTT 译注:设置是否需要选项参数,指定为 false 时此选项不带参,即为布尔选项)和帮助信息来定义选项,然后设置该选项是否为必需项(LCTT 译注:下方创建 alpha 对象的代码中未手动设置此项),最后将该选项添加到包含所有选项的 options 组对象中。在下面几行代码中,我只创建了一个选项,命名为 alpha

    //define options
    Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
    options.addOption(alpha);

在 Java 中定义带参选项

有时用户需要通过选项提供 truefalse 以外的信息,比如给出配置文件、输入文件或诸如日期、颜色这样的设置项值。这种情况可以使用 builder 方法,根据选项名简写为其创建属性(例如,-c 是短选项,--config 是长选项)。完成定义后,再将定义好的选项添加到 options 组中:

    Option config = Option.builder("c").longOpt("config")
        .argName("config")
        .hasArg()
        .required(true)
        .desc("set config file").build();
    options.addOption(config);

builder 函数可以用来设置短选项、长选项、是否为必需项(本段代码中必需项设置为 true,也就意味着用户启动程序时必须提供此选项,否则应用程序无法运行)、帮助信息等。

使用 Java 解析选项

定义并添加所有可能用到的选项后,需要对用户提供的参数进行迭代处理,检测是否有参数同预设的有效短选项列表中的内容相匹配。为此要创建命令行 CommandLine 本身的一个实例,其中包含用户提供的所有参数(包含有效选项和无效选项)。为了处理这些参数,还要创建一个 CommandLineParser 对象,我在代码中将其命名为 parser。最后,还可以创建一个 HelpFormatter 对象(我将其命名为 helper),当参数中缺少某些必需项或者用户使用 --help-h 选项时,此对象可以自动向用户提供一些有用的信息。

    // define parser
    CommandLine cmd;
    CommandLineParser parser = new BasicParser();
    HelpFormatter helper = new HelpFormatter();

最后,添加一些条件判断来分析用户提供的选项,我们假设这些选项已经作为命令行输入被获取并存储在 cmd 变量中。这个示例应用程序有两种不同类型的选项,但对这两种类型都可以使用 .hasOption 方法加上短选项名称来检测选项是否存在。检测到一个存在的选项后,就可以对数据做进一步操作了。

try {
    cmd = parser.parse(options, args);
    if(cmd.hasOption("a")) {
    System.out.println("Alpha activated");
    }

    if (cmd.hasOption("c")) {
    String opt_config = cmd.getOptionValue("config");
    System.out.println("Config set to " + opt_config);
    }
} catch (ParseException e) {
    System.out.println(e.getMessage());
    helper.printHelp("Usage:", options);
    System.exit(0);
}

解析过程有可能会产生错误,因为有时可能缺少某些必需项如本例中的 -c--config 选项。这时程序会打印一条帮助信息,并立即结束运行。考虑到此错误(Java 术语中称为异常),在 main 方法的开头要添加语句声明可能的异常:

public static void main(String[] args) throws ParseException {

示例程序至此就大功告成了。

测试代码

你可以通过调整传递给代码的默认参数来在 IDE 中测试应用程序,或者创建一个 JAR 文件并在终端运行测试。这个过程可能会因 IDE 的不同而不同。具体请参阅相应的 IDE 文档,以及我写过的关于如何创建 JAR 文件的文章,或者参考 Daniel Oh 的关于如何使用 Maven 执行同样操作的文章。

首先,省略必需项 -c--config 选项,检测解析器的异常处理:

$ java -jar dist/myapp.jar                 
Missing required option: c
usage: Usage:
 -a,--alpha             Activate feature alpha
 -c,--config <config>   Set config file

然后提供输入选项再进行测试:

java -jar dist/myantapp.jar --config foo -a
Alpha activated
Config set to foo

选项解析

为用户提供选项功能对任何应用程序来说都是很重要的。有了 Java 和 Apache Commons,要实现这个功能并不难。

以下是完整的演示代码,供读者参考:

package com.opensource.myapp;

import org.apache.commons.cli.*;

public class Main {
    
    /**
     * @param args the command line arguments
     * @throws org.apache.commons.cli.ParseException
     */ 
    public static void main(String[] args) throws ParseException {
        // define options
        Options options = new Options();
        
        Option alpha = new Option("a", "alpha", false, "Activate feature alpha");
        options.addOption(alpha);
        
        Option config = Option.builder("c").longOpt("config")
                .argName("config")
                .hasArg()
                .required(true)
                .desc("Set config file").build();
        options.addOption(config);
     
        // define parser
        CommandLine cmd;
        CommandLineParser parser = new BasicParser();
        HelpFormatter helper = new HelpFormatter();

        try {
            cmd = parser.parse(options, args);
            if(cmd.hasOption("a")) {
                System.out.println("Alpha activated");
            }
          
            if (cmd.hasOption("c")) {
                String opt_config = cmd.getOptionValue("config");
                System.out.println("Config set to " + opt_config);
            }
        } catch (ParseException e) {
            System.out.println(e.getMessage());
            helper.printHelp("Usage:", options);
            System.exit(0);
        }
    }
}

使用 Java 和选项

选项使用户可以调整命令的工作方式。使用 Java 时解析选项的方法有很多,其中之一的 commons-cli 是一个强大而灵活的开源解决方案。记得在你的下一个 Java 项目中尝试一下哦。


via: https://opensource.com/article/21/8/java-commons-cli

作者:Seth Kenlon 选题:lujun9972 译者:unigeorge 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

不管是爱它还是恨它,都很难避开 Java。

Java 仍然是一种非常流行的编程语言,在学校里教,在企业里用。

如果你想使用基于 Java 的工具或用 Java 编程,你就需要在你的系统上安装 Java。

这就变得很混乱,因为围绕着 Java 有很多技术术语。

  • Java 开发工具包 Java Development Kit (JDK)用于创建 Java 程序
  • Java 运行环境 Java Runtime Environment (JRE)或 Java 虚拟机(JVM),用于运行 Java 程序。

除此之外,你还会遇到 OpenJDKOracle Java SE。推荐使用 OpenJDK ,因为它是开源的。如果你有专门的需求,那么你应该选择 Oracle Java SE。

还有一件事。即使是 OpenJDK 也有几个版本可供选择。在写这篇文章的时候,Fedora 34 有 OpenJDK 1.8、OpenJDK 11 和 OpenJDK 16 可用。

你可以自行决定想要哪个Java版本。

在 Fedora Linux 上安装 Java

首先,检查是否已经安装了 Java,以及它是哪个版本。我不是在开玩笑。Fedora 通常预装了 Java。

要检查它,请使用以下命令:

java -version

正如你在下面的截图中看到的,我的 Fedora 系统上安装了 Java 11(OpenJDK 11)。

Check Java version

假设你想安装另一个版本的 Java。你可以用下面的命令检查可用的选项:

sudo dnf search openjdk

这里的 sudo 不是必须的,但它会刷新 sudo 用户的元数据,这在你安装另一个版本的 Java 时会有帮助。

上面的命令将显示很多输出,其中有很多看起来相似的软件包。你必须专注于最初的几个词来理解不同的版本。

Available Java versions in Fedora

例如,要安装 Java 8(OpenJDK 1.8),包的名字应该是 java-1.8.0-openjdk.x86_64 或者 java-1.8.0-openjdk。用它来安装:

sudo dnf install java-1.8.0-openjdk.x86_64

Install Java Fedora

这就好了。现在你的系统上同时安装了 Java 11 和 Java 8。但你将如何使用其中一个呢?

在 Fedora 上切换 Java 版本

你正在使用的 Java 版本保持不变,除非你明确改变它。使用这个命令来列出系统上安装的 Java 版本:

sudo alternatives --config java

你会注意到在 Java 版本前有一个数字。Java 版本前的 + 号表示当前正在使用的 Java 版本。

你可以指定这个数字来切换 Java 版本。因此,在下面的例子中,如果我输入 2,它将把系统中的 Java 版本从 Java 11 改为 Java 8。

Switching between installed Java versions

这就是你在 Fedora 上安装 Java 所需要做的一切。


via: https://itsfoss.com/install-java-fedora/

作者:Abhishek Prakash 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

一本新的展示了开发者如何继续使用 Java 框架来构建新的无服务器功能的电子书。

 title=

无服务器 架构已经成为一种高效的解决方案,无论是物理服务器、虚拟机还是云环境,都可以根据实际工作负载调整超额配置和不足配置资源(如 CPU、内存、磁盘、网络)。然而,在选择新的编程语言来开发无服务器应用时,Java 开发者有一个担忧。对于云上的无服务器部署,尤其是 Kubernetes,Java 框架似乎过于沉重和缓慢。

作为 Java 开发者,如果可以继续使用 Java 框架来构建传统的云原生微服务以及同时构建新的无服务器功能呢?这种方法应该是令人兴奋的,因为你不必担心新的无服务器应用框架的学习曲线会很陡峭。

此外,如果 Java 框架不仅可以为开发者提供熟悉技术的乐趣,还可以在启动时以毫秒为单位优化 Kubernetes 中的 Java 无服务器功能,并提供微小的内存足迹,又会怎样?

什么是 Quarkus?

Quarkus 是一个新的 Java 框架,可以为 Java 开发者、企业架构师和 DevOps 工程师提供这些功能和好处。它旨在设计无服务器应用,并编写云原生微服务,以便在云基础设施(例如 Kubernetes)上运行。

Quarkus 还支持一个名为 Funqy 的可移植 Java API 扩展,供开发者编写和部署无服务器功能到异构无服务器运行时。

Quarkus Funqy 使开发者能够将 CloudEvents 与 Knative 环境中的无服务器函数绑定,以处理反应式流。这有利于开发者建立一个通用的消息传递格式来描述事件,提高多云和混合云平台之间的互操作性。

在我的新电子书 《Java 无服务器功能指南》的帮助下,开始你的 Quarkus 之旅。与他人分享你的 Quarkus 经验,让大家都能享受到用 Java 和 Quarkus 进行的无服务器开发。


via: https://opensource.com/article/21/8/java-quarkus-ebook

作者:Daniel Oh 选题:lujun9972 译者:geekpi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出

学习 Java 如何外理数据的读与写。

 title=

当你写一个程序时,你的应用程序可能需要读取和写入存储在用户计算机上的文件。这在你想加载或存储配置选项,你需要创建日志文件,或你的用户想要保存工作以待后用的情况下是很常见的。每种语言处理这项任务的方式都有所不同。本文演示了如何用 Java 处理数据文件。

安装 Java

不管你的计算机是什么平台,你都可以从 AdoptOpenJDK 安装 Java。这个网站提供安全和开源的 Java 构建。在 Linux 上,你的软件库中也可能找到 AdoptOpenJDK 的构建。

我建议你使用最新的长期支持(LTS)版本。最新的非 LTS 版本对希望尝试最新 Java 功能的开发者来说是最好的,但它很可能超过大多数用户所安装的版本 —— 要么是系统上默认安装的,要么是以前为其他 Java 应用安装的。使用 LTS 版本可以确保你与大多数用户所安装的版本保持一致。

一旦你安装好了 Java,就可以打开你最喜欢的文本编辑器并准备开始写代码了。你可能还想要研究一下 Java 集成开发环境。BlueJ 是新程序员的理想选择,而 Eclipse 和 Netbeans 对中级和有经验的编码者更友好。

利用 Java 读取文件

Java 使用 File 类来加载文件。

这个例子创建了一个叫 Ingest 的类来读取文件中数据。当你要在 Java 中打开一个文件时,你创建了一个 Scanner 对象,它可以逐行扫描你提供的文件。事实上,Scanner 与文本编辑器中的光标是相同的概念,这样你可以用 Scanner 的一些方法(如 nextLine)来控制这个“光标”以进行读写。

import java.io.File;
import java.util.Scanner;
import java.io.FileNotFoundException;

public class Ingest {
  public static void main(String[] args) {
   
      try {
          File myFile = new File("example.txt");
          Scanner myScanner = new Scanner(myFile);
          while (myScanner.hasNextLine()) {
              String line = myScanner.nextLine();
              System.out.println(line);
          }
          myScanner.close();
      } catch (FileNotFoundException ex) {
          ex.printStackTrace();  
      } //try
    } //main
} //class

这段代码首先在假设存在一个名为 example.txt 的文件的情况下创建了变量 myfile。如果该文件不存在,Java 就会“抛出一个异常”(如它所说的,这意味着它在你试图做的事情中发现了一个错误),这个异常是被非常特定的 FileNotFoundException 类所“捕获”。事实上,有一个专门的类来处理这个明确的错误,这说明这个错误是多么常见。

接下来,它创建了一个 Scanner 并将文件加载到其中。我把它叫做 myScanner,以区别于它的通用类模板。接着,一个 while 循环将 myScanner 逐行送入文件中,只要 存在 下一行。这就是 hasNextLine 方法的作用:它检测“光标”之后是否还有数据。你可以通过在文本编辑器中打开一个文件来模拟这个过程:你的光标从文件的第一行开始,你可以用键盘控制光标来向下扫描文件,直到你走完了所有的行。

while 循环创建了一个变量 line,并将文件当前行的数据分配给它。然后将 line 的内容打印出来以提供反馈。一个更有用的程序可能会解析每一行的内容,从而提取它所包含的任何重要数据。

在这个过程结束时,关闭 myScanner 对象。

运行代码

将你的代码保存到 Ingest.java 文件(这是一个 Java 惯例,将类名的首字母大写,并以类名来命名相应的文件)。如果你试图运行这个简单的应用程序,你可能会接收到一个错误信息,这是因为还没有 example.txt 文件供应用程序加载:

$ java ./Ingest.java
java.io.FileNotFoundException:
example.txt (No such file or directory)

正好可以编写一个将数据写入文件的 Java 应用程序,多么完美的时机!

利用 Java 将数据写入文件

无论你是存储用户使用你的应用程序创建的数据,还是仅仅存储关于用户在应用程序中做了什么的元数据(例如,游戏保存或最近播放的歌曲),有很多很好的理由来存储数据供以后使用。在 Java 中,这是通过 FileWriter 类实现的,这次先打开一个文件,向其中写入数据,然后关闭该文件。

import java.io.FileWriter;
import java.io.IOException;

public class Exgest {
  public static void main(String[] args) {
    try {
        FileWriter myFileWriter = new FileWriter("example.txt", true);
        myFileWriter.write("Hello world\n");
        myFileWriter.close();
    } catch (IOException ex) {
        System.out.println(ex);
    } // try
  } // main
}

这个类的逻辑和流程与读取文件类似。但它不是一个 Scanner,而是以一个文件的名字为参数创建的一个 FileWriter 对象。FileWriter 语句末尾的 true 标志告诉 FileWriter 将文本 追加 到文件的末尾。要覆盖一个文件的内容,请移除 true 标志。

`FileWriter myFileWriter = new FileWriter("example.txt", true);`

因为我在向文件中写入纯文本,所以我在写入文件的数据(Hello world)的结尾处手动添加了换行符(\n)。

试试代码

将这段代码保存到 Exgest.java 文件,遵循 Java 的惯例,使文件名为与类名相匹配。

既然你已经掌握了用 Java 创建和读取数据的方法,你可以按相反的顺序尝试运行你的新应用程序。

$ java ./Exgest.java
$ java ./Ingest.java
Hello world
$

因为程序是把数据追加到文件末尾,所以你可以重复执行你的应用程序以多次写入数据,只要你想把更多的数据添加到你的文件中。

$ java ./Exgest.java
$ java ./Exgest.java
$ java ./Exgest.java
$ java ./Ingest.java
Hello world
Hello world
Hello world
$

Java 和数据

你不会经常向文件中写入原始文本;事实上,你可能会使用一个其它的类库以写入特定的格式。例如,你可能使用 XML 类库来写复杂的数据,使用 INI 或 YAML 类库来写配置文件,或者使用各种专门类库来写二进制格式,如图像或音频。

更完整的信息,请参阅 OpenJDK 文档


via: https://opensource.com/article/21/3/io-java

作者:Seth Kenlon 选题:lujun9972 译者:piaoshi 校对:wxy

本文由 LCTT 原创编译,Linux中国 荣誉推出