备案控制台
开发者社区 数据库 文章 正文

ORM框架的发展历史

2023-09-26 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群版 2核4GB 100GB
推荐场景：
搭建个人博客
云数据库 RDS MySQL，高可用版 2核4GB 50GB
简介： 最初的时候是直接通过jdbc来直接操作数据库的，如果本地数据库有一张t_user表，那么操作流程是

@[TOC]
image.png

JDBC

JDBC操作的特点

最初的时候是直接通过jdbc来直接操作数据库的，如果本地数据库有一张t_user表，那么操作流程是

// 注册 JDBC 驱动
Class.forName("com.mysql.cj.jdbc.Driver");

// 打开连接
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db?characterEncoding=utf-8&serverTimezone=UTC", "root", "123456");

// 执行查询
stmt = conn.createStatement();
String sql = "SELECT id,user_name,real_name,password,age,d_id from t_user where id = 1";
ResultSet rs = stmt.executeQuery(sql);

// 获取结果集
while (rs.next()) {
   
   
    Integer id = rs.getInt("id");
    String userName = rs.getString("user_name");
    String realName = rs.getString("real_name");
    String password = rs.getString("password");
    Integer did = rs.getInt("d_id");
    user.setId(id);
    user.setUserName(userName);
    user.setRealName(realName);
    user.setPassword(password);
    user.setDId(did);

    System.out.println(user);
}

具体的操作步骤是，首先在pom.xml中引入MySQL的驱动依赖，注意MySQL数据库的版本

  1. Class.forName注册驱动
  2. 获取一个Connection对象
  3. 创建一个Statement对象
  4. execute()方法执行SQL语句，获取ResultSet结果集
  5. 通过ResultSet结果集给POJO的属性赋值
  6. 最后关闭相关的资源

这种实现方式首先给我们的感觉就是操作步骤比较繁琐，在复杂的业务场景中会更麻烦。尤其是需要自己来维护管理资源的连接，如果忘记了，就很可能造成数据库服务连接耗尽。同时具体业务的SQL语句直接在代码中写死耦合性增强。每个连接都会经历这几个步骤，重复代码很多，总结上面的操作的特点：

  1. 代码重复
  2. 资源管理
  3. 结果集处理
  4. SQL耦合

JDBC优化1.0

针对常规jdbc操作的特点，可以先从代码重复和资源管理方面来优化，可以创建一个工具类来专门处理这个问题

public class DBUtils {
   
   

    private static final String JDBC_URL = "jdbc:mysql://localhost:3306/db?characterEncoding=utf-8&serverTimezone=UTC";
    private static final String JDBC_NAME = "root";
    private static final String JDBC_PASSWORD = "123456";

    private static  Connection conn;

    /**
     * 对外提供获取数据库连接的方法
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
   
   
        if(conn == null){
   
   
            try{
   
   
                conn = DriverManager.getConnection(JDBC_URL,JDBC_NAME,JDBC_PASSWORD);
            }catch (Exception e){
   
   
                e.printStackTrace();
                throw new Exception();
            }
        }
        return conn;
    }

    /**
     * 关闭资源
     * @param conn
     */
    public static void close(Connection conn ){
   
   
        close(conn,null);
    }

    public static void close(Connection conn, Statement sts ){
   
   
        close(conn,sts,null);
    }

    public static void close(Connection conn, Statement sts , ResultSet rs){
   
   
        if(rs != null){
   
   
            try {
   
   
                rs.close();
            }catch (Exception e){
   
   
                e.printStackTrace();
            }
        }

        if(sts != null){
   
   
            try {
   
   
                sts.close();
            }catch (Exception e){
   
   
                e.printStackTrace();
            }
        }

        if(conn != null){
   
   
            try {
   
   
                conn.close();
            }catch (Exception e){
   
   
                e.printStackTrace();
            }
        }
    }
}

对应的jdbc操作代码可以简化如下

    /**
     *
     * 通过JDBC查询用户信息
     */
    public void queryUser(){
   
   
        Connection conn = null;
        Statement stmt = null;
        User user = new User();
        ResultSet rs = null;
        try {
   
   
            // 注册 JDBC 驱动
            // Class.forName("com.mysql.cj.jdbc.Driver");

            // 打开连接
            conn = DBUtils.getConnection();
            // 执行查询
            stmt = conn.createStatement();
            String sql = "SELECT id,user_name,real_name,password,age,d_id from t_user where id = 1";
            rs = stmt.executeQuery(sql);

            // 获取结果集
            while (rs.next()) {
   
   
                Integer id = rs.getInt("id");
                String userName = rs.getString("user_name");
                String realName = rs.getString("real_name");
                String password = rs.getString("password");
                Integer did = rs.getInt("d_id");
                user.setId(id);
                user.setUserName(userName);
                user.setRealName(realName);
                user.setPassword(password);
                user.setDId(did);
                System.out.println(user);
            }

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

   /**
     * 通过JDBC实现添加用户信息的操作
     */
    public void addUser(){
   
   
        Connection conn = null;
        Statement stmt = null;
        try {
   
   
            // 打开连接
            conn = DBUtils.getConnection();
            // 执行查询
            stmt = conn.createStatement();
            String sql = "INSERT INTO T_USER(user_name,real_name,password,age,d_id)values('wangwu','王五','111',22,1001)";
            int i = stmt.executeUpdate(sql);
            System.out.println("影响的行数:" + i);
        } catch (SQLException se) {
   
   
            se.printStackTrace();
        } catch (Exception e) {
   
   
            e.printStackTrace();
        } finally {
   
   
            DBUtils.close(conn,stmt);
        }
    }

但是整体的操作步骤还是会显得比较复杂。

JDBC优化2.0

针对DML操作的方法来优化，先解决SQL耦合的问题，在DBUtils中封装DML操作的方法

    /**
     * 执行数据库的DML操作
     * @return
     */
    public static Integer update(String sql,Object ... paramter) throws Exception{
   
   
        conn = getConnection();
        PreparedStatement ps = conn.prepareStatement(sql);
        if(paramter != null && paramter.length > 0){
   
   
            for (int i = 0; i < paramter.length; i++) {
   
   
                ps.setObject(i+1,paramter[i]);
            }
        }
        int i = ps.executeUpdate();
        close(conn,ps);
        return i;
    }

然后在DML操作的时候我们就可以简化为如下步骤

    /**
     * 通过JDBC实现添加用户信息的操作
     */
    public void addUser(){
   
   
        String sql = "INSERT INTO T_USER(user_name,real_name,password,age,d_id)values(?,?,?,?,?)";
        try {
   
   
            DBUtils.update(sql,"wangwu","王五","111",22,1001);
        } catch (Exception e) {
   
   
            e.printStackTrace();
        }
    }

显然这种方式会比最初的使用要简化很多，但是在查询处理的时候还是没有解决ResultSet结果集的处理问题，所以还需要继续优化

JDBC优化3.0

针对ResultSet的优化需要从反射和元数据两方面入手，具体如下

    /**
     * 查询方法的简易封装
     * @param sql
     * @param clazz
     * @param parameter
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T> List<T> query(String sql, Class clazz, Object ... parameter) throws  Exception{
   
   
        conn = getConnection();
        PreparedStatement ps = conn.prepareStatement(sql);
        if(parameter != null && parameter.length > 0){
   
   
            for (int i = 0; i < parameter.length; i++) {
   
   
                ps.setObject(i+1,parameter[i]);
            }
        }
        ResultSet rs = ps.executeQuery();
        // 获取对应的表结构的元数据
        ResultSetMetaData metaData = ps.getMetaData();
        List<T> list = new ArrayList<>();
        while(rs.next()){
   
   
            // 根据 字段名称获取对应的值 然后将数据要封装到对应的对象中
            int columnCount = metaData.getColumnCount();
            Object o = clazz.newInstance();
            for (int i = 1; i < columnCount+1; i++) {
   
   
                // 根据每列的名称获取对应的值
                String columnName = metaData.getColumnName(i);
                Object columnValue = rs.getObject(columnName);
                setFieldValueForColumn(o,columnName,columnValue);
            }
            list.add((T) o);
        }
        return list;
    }

    /**
     * 根据字段名称设置 对象的属性
     * @param o
     * @param columnName
     */
    private static void setFieldValueForColumn(Object o, String columnName,Object columnValue) {
   
   
        Class<?> clazz = o.getClass();
        try {
   
   
            // 根据字段获取属性
            Field field = clazz.getDeclaredField(columnName);
            // 私有属性放开权限
            field.setAccessible(true);
            field.set(o,columnValue);
            field.setAccessible(false);
        }catch (Exception e){
   
   
            // 说明不存在 那就将 _ 转换为 驼峰命名法
            if(columnName.contains("_")){
   
   
                Pattern linePattern = Pattern.compile("_(\\w)");
                columnName = columnName.toLowerCase();
                Matcher matcher = linePattern.matcher(columnName);
                StringBuffer sb = new StringBuffer();
                while (matcher.find()) {
   
   
                    matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
                }
                matcher.appendTail(sb);
                // 再次调用复制操作
                setFieldValueForColumn(o,sb.toString(),columnValue);
            }
        }
    }

封装了以上方法后我们的查询操作就可以简化为

    /**
     *
     * 通过JDBC查询用户信息
     */
    public void queryUser(){
   
   
        try {
   
   
            String sql = "SELECT id,user_name,real_name,password,age,d_id from t_user where id = ?";
            List<User> list = DBUtils.query(sql, User.class,2);
            System.out.println(list);
        } catch (Exception e) {
   
   
            e.printStackTrace();
        }
    }

这样一来在操作数据库中数据的时候就只需要关注于核心的SQL操作了。当然以上的设计还比较粗糙，这时Apache 下的 DbUtils是一个很好的选择

Apache DBUtils

初始配置

DButils中提供了一个QueryRunner类，它对数据库的增删改查的方法进行了封装，获取QueryRunner的方式

    private static final String PROPERTY_PATH = "druid.properties";

    private static DruidDataSource dataSource;
    private static QueryRunner queryRunner;

    public static void init() {
   
   
        Properties properties = new Properties();
        InputStream in = DBUtils.class.getClassLoader().getResourceAsStream(PROPERTY_PATH);
        try {
   
   
            properties.load(in);
        } catch (IOException e) {
   
   
            e.printStackTrace();
        }
        dataSource = new DruidDataSource();
        dataSource.configFromPropety(properties);
        // 使用数据源初始化 QueryRunner
        queryRunner = new QueryRunner(dataSource);
    }

创建QueryRunner对象的时候我们需要传递一个DataSource对象，这时我们可以选择Druid或者Hikai等常用的连接池工具，这里用的是Druid。

druid.username=root
druid.password=123456
druid.url=jdbc:mysql://localhost:3306/db?characterEncoding=utf-8&serverTimezone=UTC
druid.minIdle=10
druid.maxActive=30

基本操作

QueryRunner中提供的方法解决了重复代码的问题，传入数据源解决了资源管理的问题。而对于ResultSet结果集的处理则是通过 ResultSetHandler 来处理。我们可以自己来实现该接口

    /**
     * 查询所有的用户信息
     * @throws Exception
     */
    public void queryUser() throws Exception{
   
   
        DruidUtils.init();
        QueryRunner queryRunner = DruidUtils.getQueryRunner();
        String sql = "select * from t_user";
        List<User> list = queryRunner.query(sql, new ResultSetHandler<List<User>>() {
   
   
            @Override
            public List<User> handle(ResultSet rs) throws SQLException {
   
   
                List<User> list = new ArrayList<>();
                while(rs.next()){
   
   
                    User user = new User();
                    user.setId(rs.getInt("id"));
                    user.setUserName(rs.getString("user_name"));
                    user.setRealName(rs.getString("real_name"));
                    user.setPassword(rs.getString("password"));
                    list.add(user);
                }
                return list;
            }
        });
        for (User user : list) {
   
   
            System.out.println(user);
        }
    }

或者用DBUtils中提供的默认的相关实现来解决

    /**
     * 通过ResultHandle的实现类处理查询
     */
    public void queryUserUseBeanListHandle() throws Exception{
   
   
        DruidUtils.init();
        QueryRunner queryRunner = DruidUtils.getQueryRunner();
        String sql = "select * from t_user";
        // 不会自动帮助我们实现驼峰命名的转换
        List<User> list = queryRunner.query(sql, new BeanListHandler<User>(User.class));
        for (User user : list) {
   
   
            System.out.println(user);
        }
    }

通过Apache 封装的DBUtils是能够很方便的帮助我们实现相对比较简单的数据库操作

SpringJDBC

在Spring框架平台下，也提供的有JDBC的封装操作，在Spring中提供了一个模板方法 JdbcTemplate，里面封装了各种各样的 execute,query和update方法。

JdbcTemplate这个类是JDBC的核心包的中心类，简化了JDBC的操作，可以避免常见的异常，它封装了JDBC的核心流程，应用只要提供SQL语句，提取结果集就可以了，它是线程安全的。

初始配置

在SpringJdbcTemplate的使用中，我们依然要配置对应的数据源，然后将JdbcTemplate对象注入到IoC容器中。

@Configuration
@ComponentScan
public class SpringConfig {
   
   

    @Bean
    public DataSource dataSource(){
   
   
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setUrl("jdbc:mysql://localhost:3306/db?characterEncoding=utf-8&serverTimezone=UTC");
        return  dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
   
   
        JdbcTemplate template = new JdbcTemplate();
        template.setDataSource(dataSource);
        return template;
    }
}

CRUD操作

在操作数据库中数据的时候，只需要从容器中获取JdbcTemplate实例即可

@Repository
public class UserDao {
   
   

    @Autowired
    private JdbcTemplate template;

    public void addUser(){
   
   
        int count = template.update("insert into t_user(user_name,real_name)values(?,?)","bobo","波波老师");
        System.out.println("count = " + count);
    }

    public void query2(){
   
   
        String sql = "select * from t_user";
        List<User> list = template.query(sql, new BeanPropertyRowMapper<>(User.class));
        for (User user : list) {
   
   
            System.out.println(user);
        }
    }

}

Hibernate

Apache DBUtils和SpringJdbcTemplate虽然简化了数据库的操作，但是本身提供的功能还是比较简单的(缺少缓存，事务管理等)，所以在实际开发中往往并没有直接使用上述技术，而是用到了Hibernate和MyBatis等这些专业的ORM持久层框架。

ORM介绍

ORM( Object Relational Mapping) ，也就是对象与关系的映射，对象是程序里面的对象，关系是它与数据库里面的数据的关系，也就是说，ORM框架帮助我们解决的问题是程序对象和关系型数据库的相互映射的问题

Hibernate的使用

Hibernate是一个很流行的ORM框架，2001年的时候就出了第一个版本。使用步骤如下

创建项目

创建一个Maven项目并添加相关的依赖即可，我们在此处直接通过 SpringDataJpa的依赖处理

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

配置文件

在使用Hibernate的使用，我们需要为实体类创建一些hbm的xml映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        '-//Hibernate/Hibernate Mapping DTD 3.0//EN'
        'http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd'>
<hibernate-mapping>
    <class name="com.model.User" table="t_user">
        <id name="id" />
        <property name="userName" column="user_name"></property>
        <property name="realName" column="real_name"></property>
    </class>
</hibernate-mapping>

以及Hibernate的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">
            com.mysql.cj.jdbc.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/db?characterEncoding=utf8&serverTimezone=UTC
        </property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <property name="hibernate.dialect">
            org.hibernate.dialect.MySQLDialect
        </property>

        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <mapping resource="User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

CRUD 操作

然后在程序中我们可以通过Hibernate提供的 Session对象来实现CRUD操作

public class HibernateTest {
   
   

    /**
     * Hibernate操作案例演示
     * @param args
     */
    public static void main(String[] args) {
   
   
        Configuration configuration = new Configuration();
        // 默认使用hibernate.cfg.xml
        configuration.configure();
        // 创建Session工厂
        SessionFactory factory = configuration.buildSessionFactory();
        // 创建Session
        Session session = factory.openSession();
        // 获取事务对象
        Transaction transaction = session.getTransaction();
        // 开启事务
        transaction.begin();
        // 把对象添加到数据库中
        User user = new User();
        user.setId(666);
        user.setUserName("hibernate");
        user.setRealName("持久层框架");
        session.save(user);
        transaction.commit();
        session.close();
    }
}

其他方式

在映射文件的位置，我们也可以通过注解的方式来替换掉映射文件

@Data
@Entity
@Table(name = "t_user")
public class User {
   
   

    @Id
    @Column(name = "id")
    private Integer id;

    @Column(name = "user_name")
    private String userName;

    @Column(name = "real_name")
    private String realName;

    @Column(name = "password")
    private String password;

    @Column(name = "age")
    private Integer age;

    @Column(name = "i_id")
    private Integer dId;
}

在Spring中给我们提供的JPA对持久层框架做了统一的封装，而且本质上就是基于HibernateJPA来实现的，所以我们在使用的时候也可以通过SpringDataJPA的API来操作

dao的接口只需要继承JpaRepository接口即可

public interface IUserDao extends JpaRepository<User,Integer> {
}

service层正常处理

import java.util.List;
@Service
public class UserServiceImpl implements IUserService {
   
   

    @Autowired
    private IUserDao dao;

    @Override
    public List<User> query() {
   
   
        return dao.findAll();
    }

    @Override
    public User save(User user) {
   
   
        return dao.save(user);
    }
}

Hibernate总结

Hibernate的出现大大简化了我们的数据库操作，同时也能够更好的应对更加复杂的业务场景，Hibernate具有如下的特点

  1. 根据数据库方言自定生成SQL，移植性好
  2. 自动管理连接资源
  3. 实现了对象和关系型数据的完全映射，操作对象就想操作数据库记录一样
  4. 提供了缓存机制

Hibernate在处理复杂业务的时候同样也存在一些问题

  1. 比如API中的get(),update()和save()方法，操作的实际上是所有的字段，没有办法指定部分字段，换句话说就是不够灵活
  2. 自定生成SQL的方式，如果要基于SQL去做一些优化的话，也是非常困难的。
  3. 不支持动态SQL，比如分表中的表名，条件，参数变化等，无法根据条件自动生成SQL

因此我们需要一个更为灵活的框架

MyBatis

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

“半自动”的ORM框架能够很好的解决上面所讲的Hibernate的几个问题，半自动化”是相对于Hibernate的全自动化来说的。它的封装程度没有Hibernate那么高，不会自动生成全部的SQL语句，主要解决的是SQL和对象的映射问题。

MyBatis的前身是ibatis，2001年开始开发，是“internet”和“abatis ['æbətɪs]（障碍物）”两个单词的组合。04年捐赠给Apache。2010年更名为MyBatis。

在MyBatis里面，SQL和代码是分离的，所以会写SQL基本上就会用MyBatis，没有额外的学习成本。

文章标签：
云数据库 RDS MySQL 版
Java
数据库连接
SQL
数据库
mybatis
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
lx4hkk5yox6ya
目录
相关文章
1609949562237164
|
前端开发 JavaScript 网络协议
Web开发的历史发展技术演变
本文对Web开发的历史发展的了解很有裨益，推荐给大家。本文尝试从历史发展角度，说说各种研发模式的优劣。 一、简单明快的早期时代，二、后端为主的 MVC 时代，三、Ajax 带来的 SPA 时代，四、前端为主的 MV* 时代，五、Node 带来的全栈时代
1609949562237164
1915 0
Web开发的历史发展技术演变
1100237741946300
|
1月前
|
SQL NoSQL 关系型数据库
数据库技术深度解析与未来趋势展望
一、引言 数据库技术是信息时代的基石，它支撑着无数应用的正常运行，并为企业和组织提供了强大的数据管理能力
1100237741946300
17 2
大道不孤，众行致远
|
1月前
|
Oracle NoSQL 关系型数据库
数据库漫谈-发展简史
数据管理最早都是开发者自行定义的，应用和数据管理是一体的，没有独立的数据管理系统
大道不孤，众行致远
33 8
1100237741946300
|
1月前
|
存储 SQL NoSQL
探索数据库技术的奥秘：从核心原理到行业应用
一、引言 数据库技术是现代信息科技的核心组成部分，它为我们提供了一种高效、可靠的方式来存储、检索和管理数据
1100237741946300
32 0
1100237741946300
|
1月前
|
SQL 存储 数据处理
探索数据库技术的奥秘：原理、应用与未来发展
一、引言 在当今数字化时代，数据库技术已成为支撑各种应用系统和业务运行的关键基础设施
1100237741946300
37 0
1100237741946300
|
1月前
|
存储 SQL NoSQL
探索数据库技术的奥秘：原理、应用与前沿进展
一、引言 数据库技术作为现代信息技术的核心组成部分，承载着数据存储、检索、管理和分析的重要任务
1100237741946300
30 0
1100237741946300
|
1月前
|
存储 SQL NoSQL
数据库的奥秘与力量：揭秘数据库技术的核心与前沿
一、引言 在当今信息爆炸的时代，数据库技术作为数据存储、管理与分析的基石，其重要性不言而喻
1100237741946300
14 0
1100237741946300
|
1月前
|
存储 运维 Cloud Native
数据库技术的革新与未来展望
一、引言 数据库技术作为信息时代的基石，已经深入到我们生活的各个方面
1100237741946300
19 0
泡沫o0
|
2月前
|
自然语言处理 编译器 C语言
【C/C++ 标准的发展】C/C++ 语言标准的历史和演变
【C/C++ 标准的发展】C/C++ 语言标准的历史和演变
泡沫o0
132 3
肥猪肥猪-17824
|
2月前
|
存储 安全 区块链
未来数据库技术发展趋势探析
【2月更文挑战第3天】 随着信息时代的快速发展，数据库技术作为信息存储和管理的核心工具，在不断演进与创新。本文将从人工智能、区块链、云计算等角度切入，探讨未来数据库技术的发展趋势，展望数据库技术的前景。
肥猪肥猪-17824
432 5

热门文章

最新文章

  • 1
    基于协同过滤算法的推荐
  • 2
    github—如何在README.md文件中添加图片
  • 3
    TensorFlow——module 'tensorflow' has no attribute 'xxx'
  • 4
    PostgreSQL不同模式(SCHEMA)之间迁移数据
  • 5
    微服务框架（基于开源技术的分布式、服务化框架）
  • 6
    网页中的虚拟table
  • 7
    本周链接列表(2007.12.17-2007.12.23)
  • 8
    请大家一起呼吁媒体不要进行幸还者回忆性采访
  • 9
    栈操作与栈帧 （转）
  • 10
    ECharts 之一——入门
  • 1
    mongodb 无线层级父子结构
    28
  • 2
    java接口防爬虫
    22
  • 3
    kotlin开发安卓app，如何让布局自适应系统传统导航和全面屏导航
    30
  • 4
    算法金 | 深度学习图像增强方法总结
    23
  • 5
    使用Python实现深度学习模型：文本生成与自然语言处理
    25
  • 6
    Hadoop网络带宽限制
    28
  • 7
    HadoopCPU、内存、存储限制
    24
  • 8
    HADOOP硬件资源限制
    23
  • 9
    中间件RabbitMQ性能瓶颈
    26
  • 10
    中间件Redis性能瓶颈
    19

    • 相关课程

    更多
  • 数据库开源校企合作“数据库内核从入门到精通 ”系列课
  • 高校精品课-西安交通大学 -数据库理论与技术
  • Lindorm的四大典型场景和实践
  • 关系型数据库线上预习视频
  • 2020版大数据实战项目之DMP广告系统（第五阶段）
  • 2020版大数据实战项目之DMP广告系统（第七阶段）

    • 相关电子书

    更多
  • 分析型数据库标准发展与行业观察
  • PostgresChina2018_马鹏玮_以标准推动数据库新技术的快速落地
  • 云时代的数据库技术趋势
    • 下一篇
    2024年阿里云免费云服务器及学生三百通用额度申请教程参考