JDBC---基础-低调大师

JDBC---基础

2018-04-29 532

概念

之前操作数据（客户端工具）

登录到服务器（mysql -u root -p root）
编写sql的语句
发送sql语句到数据库服务器执行

jdbc

使用java代码（程序）操作数据库（发送sql语句），的技术就是jdbc技术

使用jdbc执行sql的前提

登录数据库的服务器（连接数据库服务器）
1.数据库的IP地址
2.端口
3.数据库的用户名/密码

image.png

image.png

jdbc的接口在哪里：
java.sql.*
javax.sql.*

代码详情

package cn.persistXl.jdbc;

import org.junit.jupiter.api.Test;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;

/**
 * jdbc链接数据库
 * @author persistXL
 * @data 2018/4/29 14:51
 */
public class TestJdbc {
    //链接数据库的url

    private String url = "jdbc:mysql://localhost:3306";

    private String user = "root";
    private String password = "root";
    /**
     * 包括两部分 jdbc协议：数据库子协议：主机：端口/需要链接的数据库
     */


    /**
     *
     * 第一种相连接数据库的方法
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        //创建驱动程序类对象

        Driver driver = new com.mysql.jdbc.Driver();

        //设置一个Properties
        Properties properties = new Properties();
        properties.setProperty("user", user);
        properties.setProperty("password", password);
        //链接数据库,返回链接对象
        Connection conn = driver.connect(url,properties);

        System.out.println(conn);
    }

    /**
     * 使用驱动管理器类链接数据库
     * 第二种链接数据库的方法
     */

    @Test
    public void test1() throws SQLException {

        //注册驱动程序(可注册多个驱东程序)
        Driver driver = new com.mysql.jdbc.Driver();
        DriverManager.registerDriver(driver);

        //链接到具体的数据库
        Connection conn = DriverManager.getConnection(url, user, password);
        System.out.println(conn);
    }

    /**
     *最终的简洁版本
     */

    @Test
    public void test2() throws SQLException {


       /* Driver driver = new com.mysql.jdbc.Driver();

        //注册驱动程序(可注册多个驱东程序)
        DriverManager.registerDriver(driver);*/

       //通过字节码对象的方式加载静态代码块，从而注册驱动程序

        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //链接到具体的数据库
        Connection conn = DriverManager.getConnection(url, user, password);
        System.out.println(conn);
    }

}

常用的方式

public class TestJdbc {
    //链接数据库的url

    private String url = "jdbc:mysql://localhost:3306";

    private String user = "root";
    private String password = "root";
    /**
     * 包括两部分 jdbc协议：数据库子协议：主机：端口/需要链接的数据库
     */
 @Test
    public void test2() throws SQLException {


       /* Driver driver = new com.mysql.jdbc.Driver();

        //注册驱动程序(可注册多个驱动程序)
        DriverManager.registerDriver(driver);*/

       //通过字节码对象的方式加载静态代码块，从而注册驱动程序

        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //链接到具体的数据库
        Connection conn = DriverManager.getConnection(url, user, password);
        System.out.println(conn);
    }
}

JDBC接口的核心的API

java.sql.* 和 javax.sql.*

|---Driver 接口：表示java驱动程序接口，所有的具体的数据库厂商要来实现此接口
    |-- connect(url,properties):连接数据库的方法
          url : 连接数据库的URL
                 URL语法：jsbc协议：数据库子协议：//主机：端口/数据库
                  user：数据库的用户名
                  password：数据库用户密码
|--DriverManager 类：驱动管理器，用于管理所有的注册的驱动程序
    |--registerDriver(driver)：注册驱动类对象
    |--Connection getConnection(url,user,password); 获取连接对象
|-- Connection接口：表示Java程序和数据库的连接对象
  |--Statement createStatement（）；创建一个Statement对象
  |--PreparedStatement preparedStatement（String sql）；创建PreparedStatement对象
  |- CallableStatement prepareCall(String sql) 创建CallableStatement对象
|- Statement接口： 用于执行静态的sql语句
        |- int executeUpdate(String sql)  ： 执行静态的更新sql语句（DDL，DML）
        |- ResultSet executeQuery(String sql)  ：执行的静态的查询sql语句（DQL）

|-PreparedStatement接口：用于执行预编译sql语句
        |- int executeUpdate() ： 执行预编译的更新sql语句（DDL，DML）
        |-ResultSet executeQuery()  ： 执行预编译的查询sql语句（DQL）

|-CallableStatement接口：用于执行存储过程的sql语句（call xxx）
        |-ResultSet executeQuery()  ： 调用存储过程的方法


|- ResultSet接口：用于封装查询出来的数据
        |- boolean next() ： 将光标移动到下一行
        |-getXX() : 获取列的值

使用Statement执行sql语句

执行DDL语句（创建表）

package cn.persistXl.statement;

import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @author persistXL
 * @data 2018/4/29 16:57
 */
public class StatementTest {
    private String url = "jdbc:mysql://localhost:3306/jdbc";
    private String user = "root";
    private String password = "root";

    /**
     *
     * 执行DDL语句
     */
    @Test
    public void test(){
        int count = 0;
        Connection conn = null;
        Statement stmt = null;
        try {
            //连接数据库，注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接对象
            conn = DriverManager.getConnection(url, user, password);
            //创建statement对象
            stmt = conn.createStatement();
            //准备sql
            String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,name VARCHAR(20),gender VARCHAR(4))";
            //发送sql语句并执行,得到返回的结果
            count = stmt.executeUpdate(sql);
            //输出
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接(顺序：先打开都关闭)
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行DML语句（操作表内容）

package cn.persistXl.statement;

import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @author persistXL
 * @data 2018/4/29 18:06
 */

/**
 * 使用statement执行DML语句
 */
public class DmlTest {
    /**
     * 增加
     */
    private String url = "jdbc:mysql://localhost:3306/jdbc";
    private String name = "root";
    private String password = "root";

    @Test
    public void testInsert() throws SQLException{
        Connection conn = null;
        Statement stmt = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接对象
            conn = DriverManager.getConnection(url, name, password);
            //创建Statement对象
            stmt = conn.createStatement();
            //准备sql语句
            String sql = "insert into student(name,gender) VALUES ('zhangsan','nan')";
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void testUpdate() throws SQLException{
        Connection conn = null;
        Statement stmt = null;
        try {
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取连接对象
            conn = DriverManager.getConnection(url, name, password);
            //创建Statement对象
            stmt = conn.createStatement();
            //准备sql语句
            String sql = "UPDATE student SET gender='nv' WHERE id='1'";
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

创建公共的 db.properties

作用：当连接的数据库不是MySQL时在这里修改，当访问的数据库需要改变时在这里修改

url=jdbc:mysql://localhost:3306/day17
user=root
password=root
driverClass=com.mysql.jdbc.Driver

抽取公共类（JdbcUtil）

package cn.persistXl.util;

/**
 * @author persistXL
 * @data 2018/4/29 18:27
 */

import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * jdbc 的工具类
 */
public class JdbcUtil {
    private static String url = null;
    private static String name = null;
    private static String password = null;
    private static String driverClass = null;

    /**
     * 静态代码块（只加载一次）
     */
    static {
        try {
            //读取db.properties文件
            Properties props = new Properties();
            /**
             *  . 代表java命令运行的目录
             *  在java项目下，. java命令的运行目录从项目的根目录开始
             *  在web项目下，  . java命令的而运行目录从tomcat/bin目录开始
             *  所以不能使用点.
             */
            //FileInputStream in = new FileInputStream("./src/db.properties");               //若使用java项目时没有问题，若使用web项目时文件的路径就有问题

            /**
             * 使用类路径的读取方式
             *  / : 斜杠表示classpath的根目录
             *     在java项目下，classpath的根目录从bin目录开始
             *     在web项目下，classpath的根目录从WEB-INF/classes目录开始
             */
            InputStream in = JdbcUtil.class.getResourceAsStream("/db.properties");

            //加载文件
            props.load(in);
            //读取信息
            url = props.getProperty("url");
            name = props.getProperty("user");
            password = props.getProperty("password");
            driverClass = props.getProperty("driverClass");

            //注册驱动程序
            Class.forName(driverClass);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("驱动程序注册失败");
        }

    }

    /**
     * 抽取获取连接对象的方法
     */
    public static Connection getConnection() {
        try {
            Connection conn = DriverManager.getConnection(url, name, password);
            return conn;
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 释放资源的方法
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(Connection conn, Statement stmt) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

执行DQL语句（查询）

package cn.persistXl.statement;

/**
 * @author persistXL
 * @data 2018/4/29 19:50
 */

import cn.persistXl.util.JdbcUtil;
import org.junit.Test;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * 使用statement执行DQL语句（查询语句）
 */
public class InsertTest {
    @Test
    public void inseret(){
        Connection conn = null;
        Statement stmt = null;

        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //创建statement
            stmt = conn.createStatement();
            //准备sql
            String sql = "SELECT * FROM student";
            //执行sql
            ResultSet rs = stmt.executeQuery(sql);
            //移动光标
            boolean flag = rs.next();
            if (flag) {

                //取出列的值(根据索引值)

               /*
               int id = rs.getInt(1);
                String name = rs.getString(2);
                String gender = rs.getString(3);
                System.out.println(id+name+gender);
                */

               //根据列的名称

               /*
               int id = rs.getInt("id");
                String name = rs.getString("gender");
                String gender = rs.getString("name");
                System.out.println(id+name+gender);
                */

                //遍历结果
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("gender");
                    String gender = rs.getString("name");
                    System.out.println(id+name+gender);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

使用PreparedStatement执行sql

package cn.persistXl.PreparedStatement;

import cn.persistXl.util.JdbcUtil;
import org.junit.Test;

import java.sql.*;

/**
 * @author persistXL
 * @data 2018/4/29 20:26
 */

/**
 * 使用PreparedStatement执行sql语句
 */
public class PreparedStatementTest {
    /**
     * 增加
     */
    @Test
    public void InsertTest(){
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "insert into student (name,gender) values (?,?)";
            //?表示一个参数占位符
            //执行预编译sql语句（检查语法）
            stmt = conn.prepareStatement(sql);
            //设置参数值
            stmt.setString(1,"李四");
            stmt.setString(2,"男");
            //发送参数，执行sql
            stmt.executeUpdate();
            System.out.println(stmt);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 修改
     */
    @Test
    public void UpdateTest(){
        Connection conn = null;
        PreparedStatement stmt = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "UPDATE student SET name=? WHERE id=?";
            //?表示一个参数占位符
            //执行预编译sql语句（检查语法）
            stmt = conn.prepareStatement(sql);
            //设置参数值
            stmt.setString(1,"王五");
            stmt.setInt(2,2);
            //发送参数，执行sql
            stmt.executeUpdate();
            System.out.println(stmt);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt);
        }
    }

    /**
     * 删除
     */
    @Test
    public void DeleteTest(){
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "DELETE FROM student WHERE id=?";
            //?表示一个参数占位符

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt, rs);
        }
    }

    /**
     * 查询
     */
    @Test
    public void SelectTest(){
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备预编译sql
            String sql = "select * from student";
            //预编译
            stmt = conn.prepareStatement(sql);
            //执行sql
            rs = stmt.executeQuery();
            boolean flag = rs.next();
            System.out.println(flag);
            if (flag) {
                //便利rs
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String gender = rs.getString("gender");
                    System.out.println(id + "," + name + "," + gender);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt, rs);
        }
    }
}

两种方式的登录的比较

package cn.persistXl.PreparedStatement;

/**
 * @author persistXL
 * @data 2018/4/29 21:38
 */

import cn.persistXl.util.JdbcUtil;
import org.junit.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Statement;
import java.sql.ResultSet;

/**
 * 模拟用户登录
 */
public class Index {
    //模拟用户输入
    private String name = "admin";
    private String password = "admin";

    /**
     * statement存在sql注入风险
     */
 /*   @Test
    public void idnex(){
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
           //获取连接
            conn = JdbcUtil.getConnection();
            //创建statement
            stmt = conn.createStatement();
            //准备sql
            String sql = "select * from user where name = '"+name+"' and password = '"+password+"'";
            //执行sql
            rs = stmt.executeQuery(sql);
            if (rs.next()) {
                //登录成功
                System.out.println("登录成功");
            } else {
                //登录失败
                System.out.println("登录失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt, rs);
        }
    }*/




    @Test
    public void idnex(){
        /**
         *  PreparedStatement有效预防sql注入
         *
         */
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "select * from user where name =? and password = ?";
            //创建sql预编译
            stmt = conn.prepareStatement(sql);
            //设置参数
            stmt.setString(1, name);
            stmt.setString(2, password);
            //执行sql
            rs = stmt.executeQuery();
            if (rs.next()) {
                //登录成功
                System.out.println("登录成功");
            } else {
                //登录失败
                System.out.println("登录失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtil.close(conn, stmt, rs);
        }
    }
}
//statement登录时存在sql被注入的风险，PrepareStatement则不存在

PreparedStatement vs Statment
1）语法不同：PreparedStatement可以使用预编译的sql，而Statment只能使用静态的sql
2）效率不同： PreparedStatement可以使用sql缓存区，效率比Statment高
3）安全性不同： PreparedStatement可以有效防止sql注入，而Statment不能防止sql注入。
推荐使用PreparedStatement

CallableStatement执行存储过程

/**
 * 使用CablleStatement调用存储过程
 * @author APPle
 *
 */
public class Demo1 {
/**
     * 调用带有输入参数的存储过程
     * CALL pro_findById(4);
     */
    @Test
    public void test1(){
        Connection conn = null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            
            //准备sql
            String sql = "CALL pro_findById(?)"; //可以执行预编译的sql
            
            //预编译
            stmt = conn.prepareCall(sql);
            
            //设置输入参数
            stmt.setInt(1, 6);
            
            //发送参数
            rs = stmt.executeQuery(); //注意： 所有调用存储过程的sql语句都是使用executeQuery方法执行！！！
            
            //遍历结果
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                System.out.println(id+","+name+","+gender);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt ,rs);
        }
    }
    
    /**
     * 执行带有输出参数的存储过程
     * CALL pro_findById2(5,@NAME);
     */
    @Test
    public void test2(){
Connection conn = null;
        CallableStatement stmt = null;
        ResultSet rs = null;
        try {
            //获取连接
            conn = JdbcUtil.getConnection();
            //准备sql
            String sql = "CALL pro_findById2(?,?)"; //第一个？是输入参数，第二个？是输出参数
            
            //预编译
            stmt = conn.prepareCall(sql);
            
            //设置输入参数
            stmt.setInt(1, 6);
            //设置输出参数(注册输出参数)
            /**
             * 参数一： 参数位置
             * 参数二： 存储过程中的输出参数的jdbc类型    VARCHAR(20)
             */
            stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            
            //发送参数，执行
            stmt.executeQuery(); //结果不是返回到结果集中，而是返回到输出参数中
            
            //得到输出参数的值
            /**
             * 索引值： 预编译sql中的输出参数的位置
             */
            String result = stmt.getString(2); //getXX方法专门用于获取存储过程中的输出参数
            
            System.out.println(result);

        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            JdbcUtil.close(conn, stmt ,rs);
        }
    }
}

总结

JDBC的五部曲

//获取连接
Connection conn = JdbcUtil.getConnection();
//准备sql
 String sql = "";
//创建PreparedStatement 
PreparedStatement  pstmt = conn.prepareStatement(sql);
//设置参数值
stmt.setString(1,"");
//发送参数，执行sql
 stmt.executeUpdate();
//关闭连接（finally内关闭）
JdbcUtil.close(conn, stmt); || JdbcUtil.close(conn, stmt, rs);

微信关注我们

原文链接：https://yq.aliyun.com/articles/665886

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

C++雾中风景8：Lambda表达式

上一篇C++的博客是Long Long ago了，前文讲到在看Lambda表达式的内容。笔者首次接触Lambda表达式应该是学习Python语言的时候，当时也不太明白这种表达方式的精髓，后续接触了Scala与Java8的链式调用与Lambda结合的方式，深陷无法自拔。所以借上一篇闭包的内容。我们来完整的梳理一下C++之中的Lambda表达式。 1.什么是Lambda表达式？ Lambda表达式是函数式编程的重要的语法结构。Lambda 表达式(lambda expression)说起来很简单，就是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包。（注意和数学传统意义上的不同）。（本质上Lambda表达式就是将函数作为是一个匿名对象进行操作）其实缺少Lambda表达式的编程语言并不会影响编程语言的逻辑表达，Lambda表达式核心就是提供一个好用的语法糖：可以直接定义一个函数，而不需要将定义函数和语法内容分开，这样有助于将逻辑用更紧凑的方式表达出来。假如需要定义一个函数，恰巧这个函数仅仅使用一次，然后又需要给它定义一个名字，作为懒惰的程序员就需要搬出Lambda表达式了。...

2018-04-30

676

python版本：2.7 jdk版本：1.8 Cassandra版本：3.11.2 官网： http://cassandra.apache.org/ 下载： wget http://mirrors.tuna.tsinghua.edu.cn/apache/cassandra/3.11.2/apache-cassandra-3.11.2-bin.tar.gz 1.解压： tar xvzf apache-cassandra-3.11.2-bin.tar.gz -C ../app/ 2.修改目录名称： mv apache-cassandra-3.11.2/ cassandra-3.11.2/ 3.配置环境变量： vim ~/.bash_profile export CASSANDRA_HOME=/home/hadoop/app/cassandra-3.11.2 export PATH=$CASSANDRA_HOME/bin:$PATH source ~/.bash_profile 4.修改配置文件： vim $CASSANDRA_HOME/conf/cassandra.yaml 修改如下位置，...

2018-04-30

656

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。