一、需求：

利用jdbc实现对宠物的信息进行管理的一套系统

宠物信息：宠物ID，宠物类别，宠物名字，宠物性别，宠物年龄，宠物入库日期

系统完成功能：实现对宠物信息的录入，修改，删除，查询。

二、解决方案

一共创建了四个类：

1.一个宠物类PetMessage 里面是宠物的信息

2.一个是数据库连接类DBUtil  里面主要是完成数据连接功能

3.一个是宠物管理类PetDAO  完成对宠物信息的增删该查

4.最后一个就是一个测试类PetTest

完成对系统的测试

三、具体实现：

新建一个java项目，并导入需要用到的包。如下图：

宠物类PetMessage

  1.  package com.daliu.jdbc;
  2.  
  3.  /**
  4.   * 宠物信息类
  5.   *
  6.   */
  7.  public class PetMessage {
  8.  
  9.      //1.定义宠物的属性
  10.      // 宠物信息：宠物ID，宠物类别，宠物名字，宠物性别，宠物年龄，宠物入库日期
  11.      private int petId;
  12.      private String petSort;
  13.      private String petName;
  14.      private String petSex;
  15.      private int petAge;
  16.      private String petDate;
  17.  
  18.      //2.生成一个无参构造方法和有参构造方法
  19.  
  20.      public PetMessage(){}
  21.  
  22.      public PetMessage(int petId, String petSort, String petName, String petSex,
  23.              int petAge, String petDate) {
  24.          super();
  25.          this.petId = petId;
  26.          this.petSort = petSort;
  27.          this.petName = petName;
  28.          this.petSex = petSex;
  29.          this.petAge = petAge;
  30.          this.petDate = petDate;
  31.      }
  32.  
  33.      //3.生成属性的get，set方法
  34.      public int getPetId() {
  35.          return petId;
  36.      }
  37.      public void setPetId(int petId) {
  38.          this.petId = petId;
  39.      }
  40.      public String getPetSort() {
  41.          return petSort;
  42.      }
  43.      public void setPetSort(String petSort) {
  44.          this.petSort = petSort;
  45.      }
  46.      public String getPetName() {
  47.          return petName;
  48.      }
  49.      public void setPetName(String petName) {
  50.          this.petName = petName;
  51.      }
  52.      public String getPetSex() {
  53.          return petSex;
  54.      }
  55.      public void setPetSex(String petSex) {
  56.          this.petSex = petSex;
  57.      }
  58.      public int getPetAge() {
  59.          return petAge;
  60.      }
  61.      public void setPetAge(int petAge) {
  62.          this.petAge = petAge;
  63.      }
  64.      public String getPetDate() {
  65.          return petDate;
  66.      }
  67.      public void setPetDate(String petDate) {
  68.          this.petDate = petDate;
  69.      }
  70.  
  71.      //4.属性的toString方法，并改进为自己所要的样子
  72.      @Override
  73.      public String toString() {
  74.          return "PetMessage [petId=" + petId + ", petSort=" + petSort
  75.                  + ", petName=" + petName + ", petSex=" + petSex + ", petAge="
  76.                  + petAge + ", petDate=" + petDate + "]";
  77.      }
  78.  }

数据库连接类DBUtil

  1.  package com.daliu.jdbc;
  2.  
  3.  import java.io.InputStream;
  4.  import java.sql.Connection;
  5.  import java.sql.SQLException;
  6.  import java.util.Properties;
  7.  
  8.  import org.apache.commons.dbcp.BasicDataSource;
  9.  
  10.  /**
  11.   * 使用连接池技术管理数据库连接
  12.   */
  13.  public class DBUtil {
  14.  
  15.      // 数据库连接池
  16.      private static BasicDataSource dbcp;
  17.  
  18.      // 为不同线程管理连接
  19.      private static ThreadLocal<Connection> tl;
  20.  
  21.      // 通过配置文件来获取数据库参数
  22.      static {
  23.          try {
  24.              Properties prop = new Properties();
  25.  
  26.              InputStream is = DBUtil.class.getClassLoader().getResourceAsStream(
  27.                      "com/daliu/jdbc/db.properties");
  28.  
  29.              prop.load(is);
  30.              is.close();
  31.  
  32.              // 一、初始化连接池
  33.              dbcp = new BasicDataSource();
  34.  
  35.              // 设置驱动 (Class.forName())
  36.              dbcp.setDriverClassName(prop.getProperty("jdbc.driver"));
  37.              // 设置url
  38.              dbcp.setUrl(prop.getProperty("jdbc.url"));
  39.              // 设置数据库用户名
  40.              dbcp.setUsername(prop.getProperty("jdbc.user"));
  41.              // 设置数据库密码
  42.              dbcp.setPassword(prop.getProperty("jdbc.password"));
  43.              // 初始连接数量
  44.              dbcp.setInitialSize(Integer.parseInt(prop.getProperty("initsize")));
  45.              // 连接池允许的最大连接数
  46.              dbcp.setMaxActive(Integer.parseInt(prop.getProperty("maxactive")));
  47.              // 设置最大等待时间
  48.              dbcp.setMaxWait(Integer.parseInt(prop.getProperty("maxwait")));
  49.              // 设置最小空闲数
  50.              dbcp.setMinIdle(Integer.parseInt(prop.getProperty("minidle")));
  51.              // 设置最大空闲数
  52.              dbcp.setMaxIdle(Integer.parseInt(prop.getProperty("maxidle")));
  53.              // 初始化线程本地
  54.              tl = new ThreadLocal<Connection>();
  55.          } catch (Exception e) {
  56.              System.out.println("初始化失败，请检查配置文件是否符合！");
  57.              e.printStackTrace();
  58.          }
  59.      }
  60.  
  61.      /**
  62.       * 获取数据库连接
  63.       *
  64.       * @return
  65.       * @throws SQLException
  66.       */
  67.      public static Connection getConnection() throws SQLException {
  68.          /*
  69.           * 通过连接池获取一个空闲连接
  70.           */
  71.          Connection conn = dbcp.getConnection();
  72.          tl.set(conn);
  73.          return conn;
  74.      }
  75.  
  76.      /**
  77.       * 关闭数据库连接
  78.       */
  79.      public static void closeConnection() {
  80.          try {
  81.              Connection conn = tl.get();
  82.              if (conn != null) {
  83.                  /*
  84.                   * 通过连接池获取的Connection 的close()方法实际上并没有将 连接关闭，而是将该链接归还。
  85.                   */
  86.                  conn.close();
  87.                  tl.remove();
  88.              }
  89.          } catch (Exception e) {
  90.              System.out.println("释放资源失败！");
  91.              e.printStackTrace();
  92.              throw new RuntimeException(e);
  93.          }
  94.      }
  95.  
  96.      /**
  97.       * 测试是否连接成功
  98.       *
  99.       * @param args
  100.       * @throws SQLException
  101.       */
  102.      public static void main(String[] args) throws SQLException {
  103.          System.out.println(getConnection());
  104.      }
  105.  }

宠物管理类PetDAO

  1.  package com.daliu.jdbc;
  2.  
  3.  import java.sql.Connection;
  4.  import java.sql.ResultSet;
  5.  import java.sql.SQLException;
  6.  import java.sql.Statement;
  7.  
  8.  /**
  9.   * 宠物信息操作类
  10.   *
  11.   */
  12.  public class PetDAO {
  13.  
  14.      // 1.增添宠物信息
  15.      public static void doAdd(PetMessage pet) {
  16.  
  17.          // （1）通过宠物信息类获得宠物信息的定义
  18.          int petId = pet.getPetId();
  19.          String petSort = pet.getPetSort();
  20.          String petName = pet.getPetName();
  21.          String petSex = pet.getPetSex();
  22.          int petAge = pet.getPetAge();
  23.          String petDate = pet.getPetDate();
  24.  
  25.          // （2）与数据库连接
  26.          Connection con = null;
  27.          try {
  28.              con = DBUtil.getConnection();
  29.          } catch (SQLException e1) {
  30.              e1.printStackTrace();
  31.          }
  32.  
  33.          // （3）创建会话，执行sql语句
  34.          try {
  35.              Statement stmt = con.createStatement();
  36.              // 定义sql语句
  37.              String sqlString = "insert into petmessage(petid,petsort,petname,petsex,petage,petdate) values("
  38.                      + pet.getPetId()
  39.                      + ",'"
  40.                      + pet.getPetSort()
  41.                      + "','"
  42.                      + pet.getPetName()
  43.                      + "','"
  44.                      + pet.getPetSex()
  45.                      + "',"
  46.                      + pet.getPetAge()
  47.                      + ",'"
  48.                      + pet.getPetDate() + "');";
  49.  
  50.              // （4）执行sql语句
  51.              stmt.execute(sqlString);
  52.  
  53.              //(5)给出相应的提示
  54.              System.out.println("********************");
  55.              System.out.println("宠物添加成功！(^o^)");
  56.              System.out.println("********************");
  57.  
  58.              //(6)最后释放资源
  59.              DBUtil.closeConnection();
  60.  
  61.          } catch (SQLException e) {
  62.              // TODO 自动生成 catch 块
  63.              System.out.println("增加失败！");
  64.              e.printStackTrace();
  65.  
  66.          }
  67.      }
  68.  
  69.      //2. 根据宠物ID删除宠物信息
  70.      public static void doDeleteWithId(PetMessage pet) {
  71.  
  72.          //1.获得改宠物的信息
  73.          int petId = pet.getPetId();
  74.          String petSort = pet.getPetSort();
  75.          String petName = pet.getPetName();
  76.          String petSex = pet.getPetSex();
  77.          int petAge = pet.getPetAge();
  78.          String petDate = pet.getPetDate();
  79.  
  80.          // 2.建立数据库连接
  81.          Connection con = null;
  82.          try {
  83.              con = DBUtil.getConnection();
  84.          } catch (SQLException e1) {
  85.              e1.printStackTrace();
  86.          }
  87.          //3. 建立会话 ，执行sql语句
  88.          try {
  89.              Statement stmt = con.createStatement();
  90.              // 定义sql语句
  91.              String sqlString = "delete from petmessage where petid="
  92.                      + pet.getPetId() + ";";
  93.  
  94.              // 执行sql语句
  95.              stmt.execute(sqlString);
  96.  
  97.              //给出相应的提示
  98.              System.out.println("********************");
  99.              System.out.println("宠物删除成功！(^o^)");
  100.              System.out.println("********************");
  101.  
  102.              //关闭资源
  103.              DBUtil.closeConnection();
  104.  
  105.          } catch (SQLException e) {
  106.              // TODO 自动生成 catch 块
  107.              System.out.println("根据宠物ID删除宠物信息失败！");
  108.              e.printStackTrace();
  109.          }
  110.      }
  111.  
  112.      // 3.根据宠物名字删除宠物信息
  113.      public static void doDeleteWithName(PetMessage pet) {
  114.  
  115.          //(1)获取宠物的信息
  116.          int petId = pet.getPetId();
  117.          String petSort = pet.getPetSort();
  118.          String petName = pet.getPetName();
  119.          String petSex = pet.getPetSex();
  120.          int petAge = pet.getPetAge();
  121.          String petDate = pet.getPetDate();
  122.  
  123.          // （2）建立数据库连接
  124.          Connection con = null;
  125.          try {
  126.              con = DBUtil.getConnection();
  127.          } catch (SQLException e1) {
  128.              e1.printStackTrace();
  129.          }
  130.          // （3）建立会话，执行sql语句
  131.          try {
  132.              Statement stmt = con.createStatement();
  133.              // 定义sql语句
  134.              String sqlString = "delete from petmessage where petName="
  135.                      + pet.getPetName() + ";";
  136.              // 执行sql语句
  137.              stmt.execute(sqlString);
  138.              //给出提示
  139.              System.out.println("********************");
  140.              System.out.println("宠物删除成功！(^o^)");
  141.              System.out.println("********************");
  142.              //关闭资源
  143.              DBUtil.closeConnection();
  144.  
  145.          } catch (SQLException e) {
  146.              // TODO 自动生成 catch 块
  147.              System.out.println("根据宠物名字删除宠物信息失败！");
  148.              e.printStackTrace();
  149.          }
  150.      }
  151.  
  152.      // 4.根据宠物ID修改宠物信息
  153.      public static void doUpdateWithID(PetMessage pet) {
  154.          //（1）获取宠物信息
  155.          int petId = pet.getPetId();
  156.          String petSort = pet.getPetSort();
  157.          String petName = pet.getPetName();
  158.          String petSex = pet.getPetSex();
  159.          int petAge = pet.getPetAge();
  160.          String petDate = pet.getPetDate();
  161.  
  162.          // （2）建立数据库连接
  163.          Connection con = null;
  164.          try {
  165.              con = DBUtil.getConnection();
  166.          } catch (SQLException e1) {
  167.              e1.printStackTrace();
  168.          }
  169.          // （3）建立会话，执行sql语句
  170.          try {
  171.              Statement stmt = con.createStatement();
  172.              // 定义sql语句
  173.              String sqlString = "update petmessage set petName='"
  174.                      + pet.getPetName() + "' where petId=" + pet.getPetId()
  175.                      + ";";
  176.              // 执行sql语句
  177.              stmt.execute(sqlString);
  178.              //给出相应的提示
  179.              System.out.println("**********************");
  180.              System.out.println("宠物信息修改成功！(^o^)");
  181.              System.out.println("**********************");
  182.              //关闭资源
  183.              DBUtil.closeConnection();
  184.          } catch (SQLException e) {
  185.              // TODO 自动生成 catch 块
  186.              System.out.println("根据宠物ID修改宠物信息失败");
  187.              e.printStackTrace();
  188.          }
  189.      }
  190.  
  191.      // 5.根据宠物名字修改宠物信息
  192.      public static void doUpdateWithName(PetMessage pet) {
  193.          //（1）获取宠物信息
  194.          int petId = pet.getPetId();
  195.          String petSort = pet.getPetSort();
  196.          String petName = pet.getPetName();
  197.          String petSex = pet.getPetSex();
  198.          int petAge = pet.getPetAge();
  199.          String petDate = pet.getPetDate();
  200.  
  201.          // （2）建立数据库连接
  202.          Connection con = null;
  203.          try {
  204.              con = DBUtil.getConnection();
  205.          } catch (SQLException e1) {
  206.              e1.printStackTrace();
  207.          }
  208.          // （3）建立会话，执行sql语句
  209.          try {
  210.              Statement stmt = con.createStatement();
  211.              // 定义sql语句
  212.              String sqlString = "update petmessage set petAge='"
  213.                      + pet.getPetAge() + "' where petName=" + pet.getPetName()
  214.                      + ";";
  215.              // 执行sql语句
  216.              stmt.execute(sqlString);
  217.              //给出相应的提示
  218.              System.out.println("**********************");
  219.              System.out.println("宠物信息修改成功！(^o^)");
  220.              System.out.println("**********************");
  221.              //关闭资源
  222.              DBUtil.closeConnection();
  223.          } catch (SQLException e) {
  224.              // TODO 自动生成 catch 块
  225.              System.out.println("据宠物名字修改宠物信息失败");
  226.              e.printStackTrace();
  227.          }
  228.      }
  229.  
  230.      // 6.按ID查询宠物信息
  231.      public static void doSelectWithId(PetMessage pet) {
  232.          //（1）获取宠物信息
  233.          int petId = pet.getPetId();
  234.          String petSort = pet.getPetSort();
  235.          String petName = pet.getPetName();
  236.          String petSex = pet.getPetSex();
  237.          int petAge = pet.getPetAge();
  238.          String petDate = pet.getPetDate();
  239.          // （2）建立数据库连接
  240.          Connection con = null;
  241.          try {
  242.              con = DBUtil.getConnection();
  243.          } catch (SQLException e1) {
  244.              // TODO Auto-generated catch block
  245.              e1.printStackTrace();
  246.          }
  247.          try {
  248.              // （3）创建语句对象
  249.              Statement stmt = con.createStatement();
  250.              // （4）定义sql语句
  251.              String sqlString = "select * from petMessage where petId="
  252.                      + pet.getPetId() + ";";
  253.              //（5） 创建结果集 并执行sql语句
  254.              ResultSet rs = stmt.executeQuery(sqlString);
  255.              //（6）对结果集进行解析
  256.              System.out.println("查询结果如下：");
  257.              while (rs.next()) {
  258.                  System.out.println("宠物ID: " + rs.getInt("petId") + "   宠物种类："
  259.                          + rs.getString("petSort") + "   宠物名字："
  260.                          + rs.getString("petName") + "   宠物性别："
  261.                          + rs.getString("petSex") + "   宠物年龄："
  262.                          + rs.getInt("petAge") + "   宠物入库时间："
  263.                          + rs.getString("petDate"));
  264.              }
  265.  
  266.              //（7）关闭相应的资源
  267.              DBUtil.closeConnection();
  268.          } catch (SQLException e) {
  269.              // TODO 自动生成 catch 块
  270.              System.out.println("按ID查询宠物信息失败");
  271.              e.printStackTrace();
  272.          }
  273.      }
  274.  
  275.      // 7.按名字查询宠物信息
  276.      public static void doSelectWithName(PetMessage pet) {
  277.          //（1）获取宠物信息
  278.          int petId = pet.getPetId();
  279.          String petSort = pet.getPetSort();
  280.          String petName = pet.getPetName();
  281.          String petSex = pet.getPetSex();
  282.          int petAge = pet.getPetAge();
  283.          String petDate = pet.getPetDate();
  284.          // （2）建立数据库连接
  285.          Connection con = null;
  286.          try {
  287.              con = DBUtil.getConnection();
  288.          } catch (SQLException e1) {
  289.              // TODO Auto-generated catch block
  290.              e1.printStackTrace();
  291.          }
  292.          try {
  293.              // （3）创建语句对象
  294.              Statement stmt = con.createStatement();
  295.              //（4） 定义sql语句
  296.              String sqlString = "select * from petMessage where petName='"
  297.                      + pet.getPetName() + "';";
  298.              // （5）创建结果集 并执行sql语句
  299.              ResultSet rs = stmt.executeQuery(sqlString);
  300.              // （6）对结果集进行解析
  301.              System.out.println("查询结果如下：");
  302.              while (rs.next()) {
  303.                  System.out.println("宠物ID: " + rs.getInt("petId") + "   宠物种类："
  304.                          + rs.getString("petSort") + "   宠物名字："
  305.                          + rs.getString("petName") + "   宠物性别："
  306.                          + rs.getString("petSex") + "   宠物年龄："
  307.                          + rs.getInt("petAge") + "   宠物入库时间："
  308.                          + rs.getString("petDate"));
  309.              }
  310.              // （7）关闭所以对象
  311.              DBUtil.closeConnection();
  312.          } catch (SQLException e) {
  313.              // TODO 自动生成 catch 块
  314.              System.out.println("按名字查询宠物信息失败！");
  315.              e.printStackTrace();
  316.          }
  317.      }
  318.  }

测试类PetTest

  1.  package com.daliu.jdbc;
  2.  
  3.  public class PetTest {
  4.      public static void main(String[] args) {
  5.  
  6.          // 测试数据
  7.          // PetMessage pet=new
  8.          // PetMessage(1,"leopard","小豹子","female",5,"2014-12-19");
  9.          // PetMessage pet1=new
  10.          // PetMessage(1,"Dog","小狗狗","female",6,"2014-12-20");
  11.          // PetMessage pet2=new
  12.          // PetMessage(1,"Cat","小咪咪","female",7,"2014-12-21");
  13.          // PetMessage pet3=new
  14.          // PetMessage(1,"mouse","小老鼠","female",8,"2014-12-22");
  15.          // PetMessage pet4=new
  16.          // PetMessage(1,"elephant","大象","female",9,"2014-12-23");
  17.          // PetMessage pet5=new
  18.          // PetMessage(1,"swan","天鹅","female",10,"2014-12-24");
  19.  
  20.          // 功能测试：
  21.  
  22.          // ****1.增添宠物信息 ********
  23.          // PetDAO.doAdd(pet);
  24.          // PetDAO.doAdd(pet1);
  25.          // PetDAO.doAdd(pet2);
  26.          // PetDAO.doAdd(pet3);
  27.          // PetDAO.doAdd(pet4);
  28.          // PetDAO.doAdd(pet5);
  29.  
  30.          // ****2. 根据宠物ID删除宠物信息 ********
  31.          PetMessage pet = new PetMessage(1, "leopard", "小豹子", "female", 5,
  32.                  "2014-12-19");
  33.          pet.setPetId(1);
  34.          PetDAO.doSelectWithId(pet);
  35.  
  36.          // ****3.根据宠物名字查询宠物信息 ********
  37.          // PetMessage pet = new PetMessage(1, "leopard", "小豹子", "female", 5,
  38.          // "2014-12-19");
  39.          // pet.setPetName("小老鼠");
  40.          // PetDAO.doSelectWithName(pet);
  41.  
  42.          // ****4.根据宠物ID修改宠物信息****
  43.          // PetDAO.doUpdateWithID(pet);
  44.  
  45.          // ****5.根据宠物名字修改宠物信息****
  46.          // PetDAO.doUpdateWithName(pet);
  47.  
  48.          // ****6.根据宠物ID修改宠物信息****
  49.          // PetDAO.doDeleteWithId(pet);
  50.          // ****7.根据宠物名字修改宠物信息****
  51.          // PetDAO.doDeleteWithName(pet);
  52.      }
  53.  }

一些测试效果：

SQL脚本：

  1.  create database PegSystem;
  2.  
  3.  use PegSystem;
  4.  
  5.  create table pet(
  6.  
  7.      #private int petId;
  8.      #private String petSort;
  9.  
  10.      #private String petName;
  11.      #private String petSex;
  12.      #private int petAge;
  13.      #private String petDate;
  14.  
  15.      petId int(7),
  16.      petSort varchar(20),
  17.      petName varchar(20),
  18.      petAge int(4),
  19.      petDate  varchar(20)
  20.  );
  21.  
  22.  #select * from pet;
  23.  
  24.  rename table pet to petMessage;
  25.  
  26.  #select * from petMessage;
  27.  
  28.  alter table  petMessage add( petsex varchar(20));
  29.  
  30.  desc petMessage;
  31.  
  32.  select * from petMessage;

配置文件：

  1.  jdbc.driver=com.mysql.jdbc.Driver
  2.  jdbc.url=jdbc:mysql://localhost:3306/PegSystem
  3.  jdbc.user=root
  4.  jdbc.password=123456
  5.  initsize=1
  6.  maxactive=1
  7.  maxwait=5000
  8.  maxidle=1
  9.  minidle=1

作者：daliu_it
出处：http://www.cnblogs.com/liuhongfeng/p/4173775.html
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。谢谢合作。

JDBC实战案例--利用jdbc实现的宠物信息管理系统的更多相关文章

  1. 利用jdbc连接oracle数据库

    JDBC是Sun公司制定的一个可以用Java语言连接数据库的技术. 一.JDBC基础知识 JDBC(Java Data Base Connectivity,java 数据库连接)是一种用于执行SQL语 ...

  2. 利用JDBC连接Oracle数据库（转）

    http://blog.csdn.net/wahaha1_/article/details/8512438 JDBC是Sun公司制定的一个可以用Java语言连接数据库的技术. 一.JDBC基础知识 J ...

  3. JDBC01 利用JDBC连接数据库【不使用数据库连接池】

    目录: 1 什么是JDBC 2 JDBC主要接口 3 JDBC编程步骤[学渣版本] 5 JDBC编程步骤[学神版本] 6 JDBC编程步骤[学霸版本] 1 什么是JDBC JDBC是JAVA提供的一套 ...

  4. 利用JDBC连接Eclipse和mySQL5.1.26数据库

    初学JDBC,看了看书,自己动手的时候还是有很多地方有问题,最终终于解决了实现了数据库的连接.现将整个步骤描述如下: 环境:mySQL5.1.26(win 32bit), Eclipse JavaEE ...

  5. 【课程分享】基于plusgantt的项目管理系统实战开发(Spring3+JDBC+RMI的架构、自己定义工作流)

    基于plusgantt的项目管理系统实战开发(Spring3+JDBC+RMI的架构.自己定义工作流) 课程讲师:张弘 课程分类:Java 适合人群:中级 课时数量:37课时 用到技术:Spring  ...

  6. 利用jdbc简单封装一个小框架（类似DBUtils）

    利用jdbc写的一个类似DBUtils的框架 package com.jdbc.orm.dbutils; import java.io.IOException; import java.io.Inpu ...

  7. 利用JDBC连接数据库（MySQL）

    1 在eclipse中创建一个maven项目(在Java模式下,不要在JavaEE模式下) 1.1 file  -->> new  -->> project 2 下载数据库驱动 ...

  8. 怎样利用JDBC连接并操作Oracle数据库

    之前学习.NET的时候.以前利用ODBC进行连接数据库,而在Java中通常採用JDBC连接数据库,这里以oracle数据库为例简单的总结一下利用JDBC怎样连接并操作数据库. 1.连接 public ...

  9. 42、JDBC数据源案例

    一.JDBC数据源案例 1.概述 Spark SQL支持使用JDBC从关系型数据库(比如MySQL)中读取数据.读取的数据,依然由DataFrame表示,可以很方便地使用Spark Core提供的各种 ...

随机推荐

  1. MEF(Managed Extensibility Framework)使用全部扩展组件

    MEF(Managed Extensibility Framework),所在命名空间是System.ComponentModel.Composition.dll.简单来说,MEF是将符合约定(一般是 ...

  2. Fine Uploader + Spring3.2.2(Java+html5上传) SpringMVC+jquery-fineuploader 文件上传

    需求:要实现多文件上传,且要支持手机等移动设备... springmvc文件上传真头疼,网上搜了半天没发现都是TMD的用submit按钮提交到后台的,就没有插件的吗?最后发现了fineUploader ...

  3. Top N的MapReduce程序MapReduce for Top N items

    In this post we'll see how to count the top-n items of a dataset; we'll again use the flatland book ...

  4. 【BZOJ】【2752】【HAOI2012】高速公路(Road)

    数学期望/线段树 然而又是一道road= =上一道是2750…… 下次不要一看期望题就弃疗么…… 期望题≠不可做题……!! 其实在这题中,期望就是(所有情况下 权值之和)/(总方案数) 因为是等概率抽 ...

  5. @JVM垃圾收集器种类

    为什么要分代 之所以采用分代垃圾收集机制是因为不同的对象生命周期是不一样的.因此,不同生命周期的对象可以采取不同的收集方式,以便提高回收效率. 在Java程序运行的过程中,会产生大量的对象,其中有些对 ...

  6. QT QCharts QScatterSeries 空心点阵图，鼠标移动到上面显示数值，鼠标移开数值消失

    在最近接到的需求是这样的,画一个折线图,关键点使用空心的圆点标识出来,鼠标移动到关键点上,显示出当前数值:鼠标移走数值消失. 我们遇到这个需求的时候,第一时间就会想到使用 QLineSeries 画折 ...

  7. go语言之进阶篇值语义和引用语义

    1.值语义和引用语义 示例: package main import "fmt" type Person struct { name string //名字 sex byte // ...

  8. 牛气冲天的Iframe应用笔记

    纵观时下网站,本来网速就有些慢,可是几乎每页都要放什么Banner,栏目图片,版权等一大堆雷同的东西,当然,出于网站风格统一.广告效应的需要,本无可厚非,可毕竟让用户的钱包为这些“点缀“的东西”日益消 ...

  9. IOS网络访问详解

    第一.访问网络的方式 同步请求:数据的请求过程是由主线程发起的,网络加载需要一定的时间,因此会堵塞主线程 异步请求:数据的请求在多线程中完成 同步请求无法取消,异步请求的过程中可以取消,同步请求无法监 ...

  10. Oracle Agile PLM Web Services 的实现

    Oracle 的产品Agile PLM内置了许多Web Services,其他系统可以通过Web Servcies实现对Agile PLM系统资源的访问.快速学会使用的方法,是去Oracle的官网下载 ...