JDBC_ORM原理JAVA277-279

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量656 收藏 1
点赞数
分类专栏： JAVA 文章标签： jdbc orm java

来源：http://www.bjsxt.com/
一、S03E277_01JDBC_ORM原理、使用Object数组存储一条记录

这里写图片描述

引用表emp
这里写图片描述

#右击该properties文件--properties--Resource--Text file encoding，选中other,选择其它编码方式。
#如UTF-8或GBK,这样就能在properties里面输入中文，而不会自动转成Unicode了。

#java中的properties文件是一种配置文件，主要用于表达配置信息。
#文件类型为*.properties，格式为文本文件，文件内容是"键=值"的格式。
#在properties文件中，可以用"#"来作注释

#MySQL连接配置
mysqlDriver=com.mysql.jdbc.Driver
mysqlURL=jdbc:mysql://localhost:3306/sorm
mysqlUser=root
mysqlPwd=mysql

#Oracle连接配置
#...

package com.test.orm;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

public class JDBCUtil {

    static Properties pros = null;  //可以帮助读取和处理资源文件中的信息

    static {    //加载JDBCUtil类的时候调用
        pros = new Properties();
        try {
            pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Connection getMysqlConn(){
        try {
            Class.forName(pros.getProperty("mysqlDriver"));
            return DriverManager.getConnection(pros.getProperty("mysqlURL"),
                    pros.getProperty("mysqlUser"),pros.getProperty("mysqlPwd"));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    //可以重载多个，这里就懒得写了
    public static void close(ResultSet rs,Statement st,Connection conn){

        try {
            if (rs!=null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (st!=null) {
                st.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if (conn!=null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
package com.test.orm;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 使用Object[]来封装一条记录
 * 使用List<Object[]>存储多条记录
 */
public class Demo01 {
    public static void main(String[] args) {
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        List <Object[]> objsList = new ArrayList<Object[]>();
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id > ?");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                Object[] objs = new Object[3];  //一个Object数组封装了一条记录的信息！
                objs[0] = rs.getString(1);
                objs[1] = rs.getDouble(2);
                objs[2] = rs.getInt(3);

                objsList.add(objs);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }

        for (Object[] objs : objsList) {
            System.out.println(objs[0]+"--"+objs[1]+"--"+objs[2]);
        }
    }
}

二、S03E278_01JDBC_ORM原理、Map封装一条记录、Map和List封装多条记录

package com.test.orm;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 使用Map存储一条记录中的多行
 * 使用List<Map>存储各行中的多行
 * 使用Map<Map>存储各行中的多行
 */
public class Demo02 {
    /**
     * 使用Map存储一条记录中的多行
     */
    public static void test01(){
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        Map<String,Object> row = new HashMap<String,Object>();  //使用一个Map封装一条记录
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id = ?");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                row.put("empname", rs.getObject(1));
                row.put("salary", rs.getObject(2));
                row.put("age", rs.getObject(3));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }

        System.out.println("Map存储单行的多列：");
        //遍历Map，就是遍历这一行的多列的信息
        for (String key : row.keySet()) {
            System.out.print(key+"--"+row.get(key)+"\t");
        }
        System.out.println();
    }

    /**
     * 使用List<Map>存储各行中的多行
     */
    public static void test02(){
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        //List封装
        List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id > ? order by empname");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                Map<String,Object> row = new HashMap<String,Object>();  //使用一个Map封装一条记录
                row.put("empname", rs.getObject(1));
                row.put("salary", rs.getObject(2));
                row.put("age", rs.getObject(3));
                list.add(row);  //Map加入List
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }

        System.out.println("List存储各行的多列：");
        //遍历list
        for (Map<String, Object> map : list) {
            //遍历Map，就是遍历这一行的多列的信息
            for (String key : map.keySet()) {
                System.out.print(key+"--"+map.get(key)+"\t");
            }
            System.out.println();
        }
    }

    /**
     * 使用Map<Map>存储各行中的多行
     */
    public static void test03(){
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        //Map封装
        Map<String,Map<String,Object>> maps = new HashMap<String,Map<String,Object>>();
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id > ? order by empname");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                Map<String,Object> row = new HashMap<String,Object>();  //使用一个Map封装一条记录
                row.put("empname", rs.getObject(1));
                row.put("salary", rs.getObject(2));
                row.put("age", rs.getObject(3));
                maps.put(rs.getString(1), row); //Map加入Map
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }

        System.out.println("Map存储各行的多列：");
        //遍历Map
        for (String empname : maps.keySet()) {
            Map<String,Object> row = maps.get(empname);
            //遍历Map，就是遍历这一行的多列的信息
            for (String key : row.keySet()) {
                System.out.print(key+"--"+row.get(key)+"\t");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        test01();   //单条
        test02();   //多行
        test03();   //多行
    }
}

三、S03E279_01JDBC_ORM原理、使用javabean对象封装一条记录

package com.test.orm;

import java.sql.Date;

public class Emp {  //表结构和类对应
    private Integer id; //尽量用包装类
    private String empname;
    private Double salary;
    private Date birthday;
    private Integer age;
    private Integer depId;

    public Emp() {
    }

    public Emp(String empname, Double salary, Integer age) {
        super();
        this.empname = empname;
        this.salary = salary;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getEmpname() {
        return empname;
    }

    public void setEmpname(String empname) {
        this.empname = empname;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getDepId() {
        return depId;
    }

    public void setDepId(Integer depId) {
        this.depId = depId;
    }
}
package com.test.orm;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 使用Javabean对象存储一条记录中的多行
 * 使用List<Javabean>存储各行中的多行
 */
public class Demo03 {
    /**
     * 使用Javabean对象存储一条记录中的多行
     */
    public static void test01(){
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        Emp emp = null;
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id = ?");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                emp = new Emp(rs.getString(1), rs.getDouble(2), rs.getInt(3));
                System.out.println("Javabean对象存储一条记录中的多行");
                System.out.println(emp.getEmpname()+"--"+emp.getSalary()+"--"+emp.getAge());
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }
    }

    /**
     * 使用List<Javabean>存储各行中的多行
     */
    public static void test02(){
        Connection conn = JDBCUtil.getMysqlConn();
        PreparedStatement ps = null;
        ResultSet rs = null;
        //List封装
        List<Emp> list = new ArrayList<Emp>();
        try {
            ps = conn.prepareStatement("select empname,salary,age from emp where id > ? order by empname");
            ps.setObject(1, 1); //从1开始算参数
            rs = ps.executeQuery();

            while (rs.next()) {
                Emp emp = new Emp(rs.getString(1), rs.getDouble(2), rs.getInt(3)); 
                list.add(emp);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.close(rs, ps, conn);
        }

        System.out.println("List存储各行的多列：");
        //遍历list
        for (Emp emp : list) {
            System.out.println(emp.getEmpname()+"--"+emp.getSalary()+"--"+emp.getAge());
        }
    }

    public static void main(String[] args) {
        test01();   //单条
        test02();   //多行
    }
}
WT-TW
关注
专栏目录
springJdbcDemo11_java_springjdbc_
09-29
在这个"springJdbcDemo11_java_springjdbc_"项目中，我们将深入探讨Spring集成JDBC的基本概念、配置和核心组件，以及如何通过实例快速上手并理解其工作原理。 1. **Spring JDBC简介** Spring JDBC模块是为了简化...
Java_Library_Management_System-master.zip_Java_图书管理
09-19
2. **数据库交互**：系统必然涉及到与数据库的交互，如MySQL或Oracle等，Java提供了JDBC（Java Database Connectivity）API，可以方便地进行数据操作，包括CRUD（创建、读取、更新和删除）操作。 3. **用户身份验证...
Java-使用JDBC做一个ORM例子
果果要努力了
01-30 187
使用JDBC做一个ORM例子ORM根据id返回一个Hero对象 ORM ORM=Object Relationship Database Mapping 对象和关系数据库的映射 简单说，一个对象，对应数据库里的一条记录 根据id返回一个Hero对象 提供方法get(int id) 返回一个Hero对象 package JDBCText; public class Hero { public int id; public String name; public float hp;
JDBC 实现简单ORM映射
pan463194277的专栏
07-02 1015
原地址 ：http://www.cnblogs.com/bluedream2009/archive/2009/10/23/1588782.html   上一篇我们使用了结果集元数据实现了将结果集封装到List>中返回. ORM:对象-关系数据库映射(Object/Relation Mapping).以简单的方式提供了领域对象模型与数据库间的映射.典型的Hibernate,iBatis 这里
java_277_JDBC_ORM原理_使用Object数组存储一条记录_练习
weixin_45339692的博客
08-06 110
ORM:对象关系映射 //-------------------工具类-------------------------- package java_277_JDBC_ORM原理_使用Object数组存储一条记录_练习; import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException;
JDBC中关于封装和读取配置文件properties的问题
li12412414的博客
08-13 3791
JDBC中关于封装和读取配置文件proterties的问题。   在这个实例中，我们会对JDBC做进一步的封装。并且还为其写了资源配置文件 Db.properties.这是要注意的。我们右键src--->new File--->db.properties.这是要注意。 当然程序在实际读取的时候，还是回到bin目录下去加载db.proterties.这也是要注意的。 我们来看一下db.pro
浅析ORM框架原理
shanbaobin的博客
12-31 5450
Java是一门编程语言，控制程序逻辑 产生的数据，需要用另外程序来处理和保存（数据库、SQL专门用来操作数据的） 通信：标准 ：java出了一套自己的标准 JDBC(Java DataBase Connection)  java和数据库连接的标准 跟数据库通信的规则：数据库桥接协议 jdbc： 第一步：要建立连接 第二步：要登陆数据库 用户名和密码 第三步：要通过Java程序来发
JDBC_ORM原理_使用Object数组存储一条记录
you些话的博客
11-27 127
Demo类 package com.lzy.obj; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; public class Demo11 { public static void main(String[.
JDBC ORM原理剖析
Zllvincent的博客
07-05 1685
一.简介 Mybatis、Mybatis Plus 对数据结果集与实体类的映射关系都是通过反射技术实现，对于Mybatis Plus 的@TableField 注解映射实体也是非常有魅力。 二.实现 1.TableField.java package com.vincent.db.utils; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotatio
Spring Boot集成sharding-jdbc快速入门Demo
HBLOG
05-21 845
目前新版已经更名为ShardingSphere-JDBC ，ShardingSphere-JDBC 定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC；
000_动力节点_JDBC_源码.rar_java_jpg_noonnk4_roomqyf_动力节点源码
09-15
- JPA（Java Persistence API）和Hibernate等ORM框架，它们简化了数据库操作，提供了更高级的功能，如对象关系映射、事务管理等。 - JDBC批处理和存储过程的调用，了解如何执行复杂的数据库操作。 - 数据库连接池...
java记事簿管理系统_备忘录管理系统_通讯录_记账本-源码＋数据库＋论文or文档.zip
12-22
4. **JDBC**：Java Database Connectivity（JDBC）是Java中用于与各种数据库进行交互的标准API。开发人员会使用JDBC来连接到数据库，执行SQL查询，进行数据的增删改查操作。 5. **前端框架**：系统可能使用了...
Java面试宝典 - v1.1_Java面试宝典-v1.1_
10-01
11. **数据库相关**：掌握SQL语句，了解JDBC，以及ORM框架如Hibernate和MyBatis的使用。 12. **网络编程**：理解TCP/IP协议，HTTP协议，以及Socket编程。 13. **Java新特性**：讨论Java 8及更高版本引入的新特性，...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 614
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 253
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 567
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 551
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 444
spring boot 整合 mybatis
理解Hibernate：ORM概念与主键-id配置
在Java开发中，Hibernate是一个广泛应用的ORM框架，它允许开发者用面向对象的方式来处理数据库操作，减少了对JDBC的直接依赖。在Hibernate中，主键-id是每个持久化实体的关键部分，用于唯一标识数据库中的记录。 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值