jdbc操作mysql数据库

àì夳堔傛蜴生んèń 2022-08-10 09:54 302阅读 0赞

如何操作mysql数据库进行crud：

第一步：创建数据库

  1. DROP TABLE IF EXISTS `jdbc_user`;
  2. CREATE TABLE `jdbc_user` (
  3.   `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  4.   `name` varchar(255) DEFAULT NULL COMMENT '户用名',
  5.   `password` varchar(255) DEFAULT NULL COMMENT '户用密码',
  6.   PRIMARY KEY (`id`)
  7. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

第二步：导入mysql-connector-java的jar包

第三步：创建实体类：

  1. package com.jdbc.entity;
  3. /**
  4.  * 用户实体类 如果觉得 get / set 方法比较冗余，可以考虑使用lombok
  5.  * 
  6.  * @author ITDragon
  7.  * 
  8.  */
  9. public class User implements java.io.Serializable {
  11.     /**
  12.      * 第一步：实体类序列化
  13.      * 第二步：定义属性
  14.      * 第三步：生成get/set方法
  15.      * 第四步：创建带主键参数的构造方法
  16.      * 第五步：生成toString()方便看结果
  17.      */
  19.     private Integer id; // 用户id
  20.     private String name; // 用户名
  21.     private String password; // 用户密码
  23.     public User() {
  24.     }
  26.     public User(Integer id) {
  27.         this.id = id;
  28.     }
  30.     public Integer getId() {
  31.         return id;
  32.     }
  34.     public void setId(Integer id) {
  35.         this.id = id;
  36.     }
  38.     public String getName() {
  39.         return name;
  40.     }
  42.     public void setName(String name) {
  43.         this.name = name;
  44.     }
  46.     public String getPassword() {
  47.         return password;
  48.     }
  50.     public void setPassword(String password) {
  51.         this.password = password;
  52.     }
  54.     @Override
  55.     public String toString() {
  56.         return "User [id=" + id + ", name=" + name + ", password=" + password
  57.                 + "]";
  58.     }
  60. }

第四步：创建链接数据库工具类

  1. package com.jdbc.util;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.Statement;
  11. /**
  12.  * 数据库连接类
  13.  * @author ITDragon
  14.  *
  15.  */
  16. public class ConnectionUtil {
  18.     /**
  19.      * 第一步：加载驱动
  20.      * 第二步：链接数据库
  21.      * 第三步：一定要关闭流
  22.      * 第四步：测试是否连接成功
  23.      */
  25.     private static String DRIVER = "com.mysql.jdbc.Driver";         // 数据库驱动
  26.     private static String URL = "jdbc:mysql://localhost:3306/test";    // 访问数据库路径
  27.     private static String NAME = "root";                            // 数据库用户名
  28.     private static String PASSWORD = "root";                        // 数据库密码
  31.     public static Connection getConnection() {
  32.         Connection connection = null;
  33.         try {
  34.             // 加载驱动
  35.             Class.forName(DRIVER);
  36.             // 连接数据库
  37.             connection = DriverManager.getConnection(URL, NAME, PASSWORD);
  38.             return connection;
  39.         } catch (Exception e) {
  40.             return null;
  41.         }
  42.     }
  45.     // 关闭流
  46.     public static void closeConnection(Connection connection) {
  47.         try {
  48.             connection.close();
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         }
  52.     }
  55.     public static void closeStatement(Statement statement) {
  56.         try {
  57.             statement.close();
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  61.     }
  64.     public static void closePreparedStatement(PreparedStatement pStatement) {
  65.         try {
  66.             pStatement.close();
  67.         } catch (Exception e) {
  68.             e.printStackTrace();
  69.         }
  70.     }
  73.     public static void closeResultSet(ResultSet rs) {
  74.         try {
  75.             rs.close();
  76.         } catch (Exception e) {
  77.             e.printStackTrace();
  78.         }
  79.     }
  82.     // 测试数据库是否链接成功
  83.     public static void main(String[] args) {
  84.         System.out.println(getConnection());
  85.     }
  88. }

执行出现类似于com.mysql.jdbc.JDBC4Connection@1b8cdd5则表示执行成功

第五步：核心代码

  1. package com.jdbc.dao;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. import com.jdbc.entity.User;
  9. import com.jdbc.util.ConnectionUtil;
  11. public class UserDao {
  12.     /**
  13.      * 
  14.      * 插入数据（根据JavaBean的内容插入；所以要导入Dao类） 方法名：saveDao<BR>
  15.      * 创建人：ITDragon <BR>
  16.      * 时间：2015年2月6日-下午8:33:09 <BR>
  17.      * 
  18.      * @param dao
  19.      * @return boolean<BR>
  20.      * @exception <BR>
  21.      * @since 1.0.0
  22.      */
  23.     public static boolean saveDao(User user) {
  24.         String sql = "insert into jdbc_user(name,password) values(?,?)";
  25.         Connection connection = null;
  26.         PreparedStatement pStatement = null;
  27.         try {
  28.             connection = ConnectionUtil.getConnection();
  29.             pStatement = connection.prepareStatement(sql);
  30.             pStatement.setString(1, user.getName());
  31.             pStatement.setString(2, user.getPassword());
  32.             int count = pStatement.executeUpdate();
  33.             return count > 0 ? true : false;
  34.         } catch (Exception e) {
  35.             e.printStackTrace();
  36.             return false;
  37.         } finally {
  38.             ConnectionUtil.closePreparedStatement(pStatement);
  39.             ConnectionUtil.closeConnection(connection);
  40.         }
  41.     }
  42.     /**
  43.      * 
  44.      * 查询数据 方法名：findDaos<BR>
  45.      * 创建人：ITDragon <BR>
  46.      * 时间：2015年2月6日-下午8:55:05 <BR>
  47.      * 
  48.      * @return List<Dao><BR>
  49.      * @exception <BR>
  50.      * @since 1.0.0
  51.      */
  52.     public static List<User> findUsers() {
  53.         String sql = "select * from jdbc_user";
  54.         Connection connection = null;
  55.         PreparedStatement pStatement = null;
  56.         ResultSet rs = null;
  57.         List<User> users = null;
  58.         try {
  59.             connection = ConnectionUtil.getConnection();
  60.             pStatement = connection.prepareStatement(sql);
  61.             rs = pStatement.executeQuery();
  62.             users = new ArrayList<User>();
  63.             while (rs.next()) {
  64.                 User user = new User();
  65.                 user.setId(rs.getInt("id"));
  66.                 user.setName(rs.getString("name"));
  67.                 user.setPassword(rs.getString("password"));
  68.                 users.add(user);
  69.             }
  70.             return users;
  71.         } catch (Exception e) {
  72.             e.printStackTrace();
  73.             return null;
  74.         } finally {
  75.             ConnectionUtil.closeResultSet(rs);
  76.             ConnectionUtil.closePreparedStatement(pStatement);
  77.             ConnectionUtil.closeConnection(connection);
  78.         }
  79.     }
  80.     /**
  81.      * 
  82.      * 根据主键id删除 方法名：deleteUser<BR>
  83.      * 创建人：ITDragon <BR>
  84.      * 时间：2015年2月6日-下午9:03:55 <BR>
  85.      * 
  86.      * @param id
  87.      * @return boolean<BR>
  88.      * @exception <BR>
  89.      * @since 1.0.0
  90.      */
  91.     public static boolean deleteUser(Integer id) {
  92.         String sql = "delete from jdbc_user where id = ?";
  93.         Connection connection = null;
  94.         PreparedStatement pStatement = null;
  95.         try {
  96.             connection = ConnectionUtil.getConnection();
  97.             pStatement = connection.prepareStatement(sql);
  98.             pStatement.setInt(1, id);
  99.             int count = pStatement.executeUpdate();
  100.             return count > 0 ? true : false;
  101.         } catch (Exception e) {
  102.             e.printStackTrace();
  103.             return false;
  104.         } finally {
  105.             ConnectionUtil.closePreparedStatement(pStatement);
  106.             ConnectionUtil.closeConnection(connection);
  107.         }
  108.     }
  109.     /**
  110.      * 
  111.      * 根据主键id修改数据 方法名：updateUser<BR>
  112.      * 创建人：ITDragon <BR>
  113.      * 时间：2015年2月6日-下午9:17:03 <BR>
  114.      * 
  115.      * @param name
  116.      * @param password
  117.      * @param id
  118.      * @return boolean<BR>
  119.      * @exception <BR>
  120.      * @since 1.0.0
  121.      */
  122.     public static boolean updateUser(String name, String password, Integer id) {
  123.         // name 和 password之间只能用 ","隔开
  124.         String sql = "update jdbc_user set name = ? , password = ?  where id = ?";
  125.         Connection connection = null;
  126.         PreparedStatement pStatement = null;
  127.         try {
  128.             connection = ConnectionUtil.getConnection();
  129.             pStatement = connection.prepareStatement(sql);
  130.             pStatement.setString(1, name);
  131.             pStatement.setString(2, password);
  132.             pStatement.setInt(3, id);
  133.             int count = pStatement.executeUpdate();
  134.             return count > 0 ? true : false;
  135.         } catch (Exception e) {
  136.             e.printStackTrace();
  137.             return false;
  138.         } finally {
  139.             ConnectionUtil.closePreparedStatement(pStatement);
  140.             ConnectionUtil.closeConnection(connection);
  141.         }
  142.     }
  143. }

第六步：测试类

  1. package com.jdbc.test;
  3. import java.util.List;
  5. import org.junit.Test;
  7. import com.jdbc.dao.UserDao;
  8. import com.jdbc.entity.User;
  10. /**
  11.  * 测试User的crud
  12.  * @author ITDragon
  13.  *
  14.  */
  15. public class UserTest {
  17.     @Test
  18.     public void findUserTest(){
  19.         List<User> users= UserDao.findUsers();
  20.         for (User user : users) {
  21.             System.out.println(user);
  22.         }
  23.     }
  25.     @Test
  26.     public void saveUserTest(){
  27.         User user = new User();
  28.         user.setName("ITDragon");
  29.         user.setPassword("麻麻说密码太长容易记得");
  30.         boolean flag = UserDao.saveDao(user);
  31.         if (flag) {
  32.             System.out.println(user.getName()+"保存成功");
  33.         } else {
  34.             System.out.println("保存失败");
  35.         }
  36.     }
  38.     @Test
  39.     public void updateUserTest(){
  40.         boolean flag = UserDao.updateUser("NewITDragon", "麻麻说错了", 1);
  41.         if (flag) {
  42.             System.out.println("更新成功");
  43.         } else {
  44.             System.out.println("更新失败");
  45.         }
  46.     }
  48.     @Test
  49.     public void deleteUserTest(){
  50.         boolean flag = UserDao.deleteUser(1);
  51.         if (flag) {
  52.             System.out.println("删除成功");
  53.         } else {
  54.             System.out.println("删除失败");
  55.         }
  56.     }
  58. }

资料下载地址：http://download.csdn.net/detail/qq_19558705/9285827

个人主页：http://www.itit123.cn/ 更多干货等你来拿

有什么疑问和建议可以留言。

发表评论

表情：
评论列表 （有 0 条评论，302人围观）

还没有评论，来说两句吧...

相关阅读