JDBC高级

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量188 收藏
点赞数
分类专栏： 数据库 Java 文章标签： jdbc java sql mysql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Harvesters/article/details/105077064
版权

1. Statement操作SQL语句

1.1 Statement查询SQL数据操作

package com.my.demo1;

import com.my.domain.User;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
        List<User> list = new Demo1().findAll();
        System.out.println(list);
    }
    public List<User> findAll() {
        Statement statement = null;
        Connection connection = null;
        ResultSet users = null;
        User user = null;
        List<User> friends = new ArrayList<>();
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String URL = "jdbc:mysql://localhost:3306/feige001? useSSL=true";
            String USER = "root";
            String PASSWORD = "123456";
            connection = DriverManager.getConnection(URL, USER, PASSWORD);
            statement = connection.createStatement();
            String sql = "select * from user ";
            users = statement.executeQuery(sql);
            while (users.next()) {
                int id = users.getInt(1);
                String name = users.getString("name");
                String ps = users.getString("password");
                user = new User(id,name,ps);
                friends.add(user);
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            if (users != null) {
                try {
                    users.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return friends;
    }
}

2. JDBC工具类封装

需要完成的内容
1. 数据库连接对象java.sql.Connection获取过程
2. 关闭资源
JDBC工具类
1. 所有的方法都是static修饰的静态方法
2. 2. 需要考虑自动加载过程，完成一些必要数据的自动处理
url driver user password
3. 所需数据库连接条件保存到文件中
4. 关闭方法提供多种多样组合方法
【注意】 db.properties文件保存到src目录下
数据库配置文件 db.properties

URL = jdbc:mysql://localhost:3306/feige001? useSSL=true
USER = root
PASSWORD = 123456
DRIVER = com.mysql.jdbc.Driver

工具封装
package com.my.utils;

import java.io.FileReader;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    private static String url;
    private static String user;
    private static String ps;
    private static String driver;
    /**
     * 读取配置文件
     */
    static {
        try {
            Properties properties = new Properties();
            properties.load(new FileReader(JDBCUtils.class.getClassLoader().getResource("db.properties").getPath()));
            url = properties.getProperty("URL");
            user = properties.getProperty("USER");
            ps = properties.getProperty("PASSWORD");
            driver = properties.getProperty("DRIVER");
            Class.forName(driver);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     * @return
     * @throws SQLException
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,ps);
    }

    /**
     * 释放资源
     * @param rs
     * @param statement
     * @param connection
     */
    public static void close(ResultSet rs, Statement statement,Connection connection) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void closeAll(Connection connection) {
        close(null,null,connection);
    }
    public static void closeAll(Connection connection,Statement statement) {
        close(null,statement,connection);
    }
    public static void closeAll(Connection connection,Statement statement,ResultSet resultSet) {
        close(resultSet,statement,connection);
    }
}

3. PreparedStatement使用

3.1 PreparedStatement插入数据SQL完成

@Test
    public void testInsert() {
        User user = new User(5 ,"昊昊","123456");
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql ="insert into user(id,name,password) value (?,?,?)";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,user.getId());
            preparedStatement.setObject(2,user.getName());
            preparedStatement.setObject(3,user.getPassword());
            int i = preparedStatement.executeUpdate();
            System.out.println(i);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement);
        }
    }

3.2 PreparedStatment修改SQL完成

/**
     * 修改用户
     */
    @Test
    public void testUpdate() {
        User user = new User(1 ,"陈冠希","666666");
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql ="update user set name =?,password =? where id =?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,user.getName());
            preparedStatement.setObject(2,user.getPassword());
            preparedStatement.setObject(3,user.getId());
            int i = preparedStatement.executeUpdate();
            System.out.println(i);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement);
        }
    }

3.3 PreparedStatment删除SQL完成

/**
     * 删除用户
     */
    @Test
    public void testDelete() {
        int id = 5;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql ="delete from user where id=?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,id);
            int i = preparedStatement.executeUpdate();
            System.out.println(i);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement);
        }
    }

3.4 PreparedStatment查询SQL完成

/**
     * 查询指定用户
     */
    @Test
    public void testSelectOne() {
        int id = 2;
        User user = null;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql ="select * from user where id =?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,id);
            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()) {
                user = new User(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3));
            }
            System.out.println(user);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement,resultSet);
        }
    }


/**
     * 查询所有用户
     */
    @Test
    public void testSelectAll() {
        List<User> list = new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql ="select * from user";
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                list.add(new User(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3)));
            }
            for (User user : list) {
                System.out.println(user);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement,resultSet);
        }
    }

4. SQL注入问题

Statement是一个SQL语句搬运工对象，不存在SQL语句语预处 理能力，Java代码SQL语句原封不动搬运到数据库！！！ PreparedStatement 存在SQL语句预处理过程，这个过程可 以有效的防止一定条件的SQL注入 Statement存在SQL注入问题，而PreparedStatemen可以有 效的避免SQL注入
强烈推荐使用PreparedStatement

1. PreparedStatement操作性更强    2. PreparedStatement安全性更高

5. BaseDao封装

5.1 需求和问题

需求
1. 完成通用的更新方法，满足insert，update，delete操作
2. 完成通用的查询方法，满足select
问题
1. 数据库连接对象获取[解决]
2.资源关闭[解决]
3.PreparedStatement参数赋值过程【未解决】
a. 参数个数 PreparedStatement预处理SQL语句?有多少个
b. 赋值顺序‘ 参数传入方式和顺序问题
2. 查询结果集解析过程【未解决】
a. 返回值是一个List<目标数据类型>集合
b. 返回值是一个Object数组

5.2 【补充知识点-元数据】

三种元数据
数据库元数据
通过java.sql.Connection获取对应的元数据

/**
     * 获取数据库元数据
     */
    @Test
    public void test1() {
        try {
            Connection connection = JDBCUtils.getConnection();
            DatabaseMetaData databaseMetaData = connection.getMetaData();
            String userName = databaseMetaData.getUserName();
            String driverName = databaseMetaData.getDriverName();
            String version = databaseMetaData.getDriverVersion();
            String url = databaseMetaData.getURL();
            System.out.println(userName);
            System.out.println(driverName);
            System.out.println(version);
            System.out.println(url);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

SQL语句元数据
        通过java.sql.PreparedStatement获取对应的元数据

@Test
    public void test2() {
        try {
            Connection connection = JDBCUtils.getConnection();
            String sql = "insert into user(id, name, password) VALUE (?,?,?)";
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            ParameterMetaData parameterMetaData = preparedStatement.getParameterMetaData();
            int count = parameterMetaData.getParameterCount();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

 数据库结果集元数据
         通过java.sql.ResultSet获取对应的元数据

@Test
    public void test3() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtils.getConnection();
            String sql = "select * from user";
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            while (resultSet.next()) {
                for (int i = 1; i <= columnCount; i++) {
                    System.out.println(metaData.getColumnName(i) + ":" + resultSet.getObject(i));

                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement,resultSet);
        }
    }

 MetaData 【重点】
     1. SQL语句元数据，参数元数据其中的参数个数 对应 ? 占位符个数
     2. 结果集元数据中的字段个数，和对应当前字段下标的字段名字

5.3 【补充知识点 BeanUtils使用】

BeanUtils提供了对于符合JavaBean规范的实体类进行赋值，取值，拷贝操作的一系列方法，可以自动完成数据类型转换，方 便开发者在数据交互中使用。 所有的方法都是静态方法
三个方法
1. 赋值指定成员变量对应数据
a. 符合JavaBean规范的类对象
b. 指定成员变量的名字
c. Object类型数据用于赋值成员变量

 @Test
    public void test1() throws InvocationTargetException, IllegalAccessException {
        User user = new User();
        BeanUtils.setProperty(user, "id","10");
        BeanUtils.setProperty(user, "name","彭于晏");
        BeanUtils.setProperty(user, "password",123456);
        System.out.println(user);
    }

         2. 取值指定成员变量的数据
         a. 符合JavaBean规范的类对象
         b. 指定成员变量的名字
             返回值是对应当前成员变量的数据类型

@Test
    public void test2() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        User user = new User(11 , "锤子" ,"123456");
        System.out.println(BeanUtils.getProperty(user,"id"));
        System.out.println(BeanUtils.getProperty(user,"name"));
        System.out.println(BeanUtils.getProperty(user,"password"));
    }

        3. 拷贝符合JavaBean规范的两个对象数据
        a. 符合JavaBean规范的目标类对象
        b. 符合JavaBean规范的目标数据源对象 

@Test
    public void test3() throws InvocationTargetException, IllegalAccessException {
        User user1 = new User(111 , "棒子", "111222");
        User user2 = new User();
        System.out.println("user1:" + user1);
        System.out.println("user2:" + user2);
        BeanUtils.copyProperties(user2,user1);
        System.out.println("user1:" + user1);
        System.out.println("user2:" + user2);
    }

        4. 真香方法，从Map双边对联中匹配赋值数据到符合 JavaBean规范的  
            类对象
      a. 符合JavaBean规范的类对象            b. Map双边队列

@Test
    public void test4() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        HashMap<String , String> map = new HashMap<>();
        map.put("id","222");
        map.put("name","飞哥哥");
        map.put("password","666666");
        User user = new User();
        BeanUtils.populate(user,map);
        System.out.println(user);
        System.out.println(BeanUtils.getProperty(user,"id"));
        System.out.println(BeanUtils.getProperty(user,"name"));
        System.out.println(BeanUtils.getProperty(user,"password"));
    }

5.4 通用更新方法实现

分析:
完成通用的更新方法，update,insert,delete操作
权限修饰符:
public
返回值类型：
int 当前SQL语句参数，数据库收到影响的行数
方法名: update
形式参数列表:
1. String sql语句
、指定执行的SQL语句 update insert delete。。。
2. SQL语句可能需要参数
SQL有可能没有参数，有可能多个参数，而且参数类 型都不一
样！！！
a. Object… Object类型的不定长参数
b. Object[] 所有对应当前SQL语句的参数都存储在
Object 类型数组中 (String sql, Object[] parameters)
方法声明: public int update(String sql, Object[] parameters)

/**
     * 通用的更新方法
     * @param sql 需要执行的sql语句
     * @param parameters 对应当前sql语句的参数列表
     * @return 返回数据库收到影响的数据行数
     */
    public int update(String sql , Object... parameters) {
        int affectedRows = 0;
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            int count = preparedStatement.getParameterMetaData().getParameterCount();
            if (count != 0 && parameters != null && count ==parameters.length) {
                for (int i = 0; i < parameters.length ; i++) {
                    preparedStatement.setObject(i+1 ,parameters[i]);
                }
            }
            affectedRows  = preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement);
        }
        return affectedRows;
    }

5.5 通用查询方法实现

分析:
完成通用的查询方法，select操作
权限修饰符:
public
需要声明泛型 T ==> Type
返回值类型： List<指定数据类型>
方法名: query
形式参数列表:
1. String sql语句
指定执行的SQL语句 Select语句
2. SQL语句可能需要参数
SQL有可能没有参数，有可能多个参数，而且参数类型都不一
样！！！
a. Object… Object类型的不定长参数
b. Object[] 所有对应当前SQL语句的参数都存储在Object 类型数组中
3. 告知当前SQL语句出现的查询结果对应数据类型是哪一 个 Class cls
a. 泛型T 用于数据类型约束，传入哪一个类的.class当 前T对应的就是哪一个类
b. Class 反射对应的Class类对象
为所欲为！！！
有了对应类的.class字节码文件对应Class对 象。可以通过反射为所欲
为 (String sql, Object[] parameters, Class cls)
方法声明: public List query(String sql, Object[] parameters, Class cls)

 /**
     * 通用查找方法
     * @param sql 需要执行的sql语句
     * @param parameters 与sql语句对应的参数列表
     * @param cls 指定数据类型的class对象
     * @param <T> 泛型占位符
     * @return 返回查找的结果集合
     */
    public <T> List<T> query(String sql,Object[] parameters,Class<T> cls) {
        ResultSet resultSet = null;
        Connection connection = null ;
        PreparedStatement preparedStatement = null;
        List<T> list = new ArrayList<>();
        try {
            connection = JDBCUtils.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            int count = preparedStatement.getParameterMetaData().getParameterCount();
            if (count!=0 && parameters != null && parameters.length == count) {
                for (int i = 0; i<parameters.length; i++) {
                    preparedStatement.setObject(i+1,parameters[i]);
                }
            }
            resultSet = preparedStatement.executeQuery();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int columnCount = metaData.getColumnCount();
            while (resultSet.next()) {
                T t = cls.getConstructor().newInstance();
                for (int i =1 ;i<=columnCount ; i++) {
//                    String columnName = metaData.getColumnName(i);
//                    Object value = resultSet.getObject(columnName);
//                    BeanUtils.setProperty(t,columnName,value);
                    BeanUtils.setProperty(t,metaData.getColumnName(i),resultSet.getObject(i));

                }
                list.add(t);
            }
        } catch (SQLException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeAll(connection,preparedStatement,resultSet);
        }
        return list.size() != 0 ? list : null;
    }
}
Harvesters
关注
专栏目录
JDBC高级（一）
12-21
1. Statement 查询SQL数据操作 1.1 Statement查询SQL数据操作 这里需要先准备好一个User类，属性包含int id、 String userName、String password。以及构造方法、操作方法 （1）查询指定的一个数据行，转换成对应的...
基于jsp的原生分页查询。
DL代先生
01-12 202
servlet代码 package com.dl.controller; import com.dl.entity.Student; import com.dl.service.StudentService; import com.dl.service.impl.StudentServiceImpl; import com.dl.utils.PageUtil; import javax.servlet.ServletException; import javax.servlet.annotat.
使用java代码控制sql_Java代码 简单用于处理和数据库相关的操作
weixin_33595317的博客
02-26 274
package util;import org.apache.commons.beanutils.BeanUtils;import java.lang.reflect.InvocationTargetException;import java.sql.*;import java.util.ArrayList;import java.util.List;/*** 基础DAO层，用于处理和数据库相关的...
python实现将dataframe直接插入Elasticsearch数据库的方法
weixin_43025542的博客
11-19 1060
由于比较喜欢使用pandas包中的dataframe进行数据预处理，处理完后需要导入到数据库中，为避免重复转换数据格式，一下函数可直接完成导入。 from elasticsearch import Elasticsearch def connect_es(frame, index_, type_): try: es = Elasticsearch(host, http_auth=(user, password), port='9200') df_as_json
JDBC高级操作
sm1253的博客
11-21 950
模拟淘宝登录功能 后台返回User类的数据，前台处理后台返回的数据，如果为空说明登录失败 public static void main(String[] args) { //1.输入用户名和密码 Scanner sc =new Scanner(System.in); System.out.println("请输入用户名:"); String username = sc.nextLine(); System....
JDBC高级操作PreparedStatement
sm1253的博客
11-21 707
PreparedStatement高i姓名体现在插入数据 JDBC事务转账安全 一个转账减去了2000，另一个却失败了，这里就需要引入事务处理。这里的意思是两个操作要同步，不能一个成功，另一个却失败 如果他们两个有一条语句出错，那么就不会执行commit，会去执行回滚 完整代码 package com.JDBC2; import java.sql.Connection; import java.sql.DriverManager; import java....
三天学会JDBC（三）JDBC高级
长夜漫漫，无心睡眠
01-29 2643
一.SQL注入及解决方案 1.SQL注入介绍 SQL注入是指利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的SQL语句段或者命令，从而利用系统的SQL引擎完成恶意行为的做法。 修改account表通用查询，使用Statement实现 即把 PreparedStatement 换成 Statement ，取消预编译 修改登录实现代码 测试用例正常 以上输入的账号和密码，通过SQL拼接，在执行过程中的SQL实际上是： select *..
JDBC高级篇-JDBC工具类、DAO封装和BaseDAO工具类
weixin_44201223的博客
04-12 707
JDBC优化及工具类封装、ThreadLocal、DAO封装及BaseDAO工具类
J2EE之 JDBC高级查询
07-15 143
高级查询： where 1=1 很耗费资源
MySQL使用JDBC高级操作和事务
♾️
12-14 2092
JDBC批处理和事务 回顾 1 jdbc介绍 ： Java Database Connectity java数据库连接技术 定义一套连接数据的规范和标准。 2 jdbc包含两个部分 JDBC API JDBC 驱动程序 3 JDBC的使用步骤 1 导入jar包 2 注册驱动 3 获取连接 3306 4 创建命令 5 执行命令，处理结果 6 释放资源 ...
Jdbc高级（存储过程、事务、批处理）
shdhdj2838的博客
07-18 972
四大特性：CRID 原子性、一致性、隔离性、持久性。6.2 如果增删改sql，返回受影响的行数。5.1 如果sql有占位符，设置占位符值。1. 设置提交方式为手动提交。4. 获取连接对象，与数据库建立连接。6.1 如果查询sql，返回结果集。看成一个整体，要么都成功，要么都失败。3. 如果输入参数in,设置值。6. 执行sql语句，返回结果。7. 关闭 (后创建的先关闭)1. 引入jdbc的jar包。. 获取命令对象，发送sql语句。关闭顺序一定要从小到大来进行关闭。1.存储过程的sql语句（
jdbc高级开发代码和实践
05-31
Region的结构：先不看其他，先看storeFile 12、 看完了物理存储，再来看架构：4种角色的机器，zookeeper是集群同步工具 13、 Region定位->三级索引 14、 表的一次写过程：WAL,memstore，flush ...
JDBC高级批处理
04-11
**JDBC高级批处理** Java Database Connectivity (JDBC) 是Java平台中用于与数据库交互的一组接口和类，它是Java标准API的一部分，允许Java开发者执行SQL语句并处理结果。在处理大量数据时，JDBC提供了批处理功能，...
spring事务详细讲解-深入浅出
小电玩
09-08 533
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1517
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
yang_brother的博客
09-10 580
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 612
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 570
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Java JDBC高级技术：处理中文与分页
总结起来，JDBC高级技术涵盖了多方面的内容，包括解决跨平台和跨环境的中文显示问题、高效的数据分页查询、存储和检索二进制数据，以及利用高级开发框架提升开发效率。理解和掌握这些技术对于开发高质量的Java数据库...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值