JDBC学习总结5-------使用了内部类后的改造

最新推荐文章于 2025-09-12 18:08:49 发布
最新推荐文章于 2025-09-12 18:08:49 发布
阅读量66 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 数据库
原文链接：https://yq.aliyun.com/articles/512982

1.com.hanchao.entity包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package  com.hanchao.entity; 
/** 
  * 实体类 
  * @author hanlw 
  * 2012-07-09 
  */ 
public  class  User { 
  
     private  int  id; 
     private  String username; 
     private  String address; 
      
     //get...set...方法 
     public  int  getId() { 
         return  id; 
     } 
     public  void  setId( int  id) { 
         this .id = id; 
     } 
     public  String getUsername() { 
         return  username; 
     } 
     public  void  setUsername(String username) { 
         this .username = username; 
     } 
     public  String getAddress() { 
         return  address; 
     } 
     public  void  setAddress(String address) { 
         this .address = address; 
     } 
      
}

2.com.hanchao.util包

《1》.一个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package  com.hanchao.util; 
  
import  java.sql.ResultSet; 
import  java.sql.SQLException; 
  
/** 
  * 顶一个泛型的RowMapper接口 
  * @author hanlw 
  * 2012-07-09 
  */ 
public  interface  RowMapper<T> { 
     /** 
      * 注意：T表示一个泛型的实体类。 
      */ 
     public  T mapperRow(ResultSet rs)  throws  SQLException; 
}

《2》.工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
package  com.hanchao.util; 
  
import  java.sql.Connection; 
import  java.sql.DriverManager; 
import  java.sql.PreparedStatement; 
import  java.sql.ResultSet; 
import  java.sql.SQLException; 
import  java.util.ArrayList; 
import  java.util.List; 
  
/** 
  * 顶一个泛型的工具类 
  * @author hanlw 
  * 2012-07-09 
  */ 
public  class  DBHelp<T> { 
     //定义几个常量 
     private  static  final  String DRIVER =  "com.mysql.jdbc.Driver" ; 
     private  static  final  String URL =  "jdbc:mysql://127.0.0.1:3306/mydb" ; 
     private  static  final  String DB_NAME =  "root" ; 
     private  static  final  String DB_PASSWORD =  "root" ; 
      
     /** 
      * 连接数据库 
      * @return 
      */ 
     public  Connection getConnection() { 
         Connection con =  null ; 
         try  { 
             Class.forName(DRIVER); 
             con = DriverManager.getConnection(URL,DB_NAME,DB_PASSWORD); 
         }  catch  (Exception e) { 
             e.printStackTrace(); 
         } 
         return  con; 
     } 
      
     /** 
      * 返回一个对象的查询 
      * @param sql SQL语句 
      * @param rm  该接口的所有实现类对象 
      * @param args 不定项参数 
      * @return 
      */ 
     public  T queryForObject(String sql, RowMapper<T> rm, Object...args) { 
         Connection con = getConnection(); 
         PreparedStatement sta =  null ; 
         ResultSet rs =  null ; 
          
         T obj =  null ; 
          
         try  { 
             sta = con.prepareStatement(sql); 
             for  ( int  i =  0 ; i < args.length; i++) { 
                 sta.setObject(i+ 1 , args[i]); // 
             } 
             rs = sta.executeQuery(); 
             if (rs.next()) { 
                 obj = rm.mapperRow(rs); //实际上运行是其实现类中的mapperRow()方法，即实现类重现后的方法 
             } 
              
         }  catch  (SQLException e) { 
             e.printStackTrace(); 
         }  finally  { 
             close(rs,sta,con); 
         } 
          
         return  obj; 
     } 
      
     /** 
      * 返回一个集合的查询 
      * @param sql → SQL语句 
      * @param rm → RowMapper<T>接口的实现类对象 
      * @param args → 不定项参数 
      * @return 
      */ 
     public  List<T> queryForList(String sql,RowMapper<T> rm, Object...args) { 
         Connection con = getConnection(); 
         PreparedStatement sta =  null ; 
         ResultSet rs =  null ; 
          
         List<T> list =  new  ArrayList<T>(); 
          
         try  { 
             sta = con.prepareStatement(sql); 
             for  ( int  i =  0 ; i < args.length; i++) { 
                 sta.setObject(i+ 1 , args[i]); 
             } 
              
             rs = sta.executeQuery(); 
             while (rs.next()) { 
                 T obj = rm.mapperRow(rs); 
                 list.add(obj); 
             } 
              
         }  catch  (SQLException e) { 
             e.printStackTrace(); 
         }  finally  { 
             close(rs,sta,con); 
         } 
         return  list; 
     } 
      
     /** 
      * 用来执行insert、update、delete方法 
      * @param sql → SQL语句 
      * @param args → 不定项参数 
      * @return 
      */ 
     public  int  executeSQL(String sql, Object...args) { 
         Connection con = getConnection(); 
         PreparedStatement sta =  null ; 
         int  rows =  0 ; 
          
         try  { 
             sta = con.prepareStatement(sql); 
             for  ( int  i =  0 ; i < args.length; i++) { 
                 sta.setObject(i+ 1 , args[i]); 
             } 
              
             rows = sta.executeUpdate(); 
             if (rows >  0 ) { 
                 System.out.println( "ok" ); 
             }  else  { 
                 System.out.println( "no" ); 
             } 
         }  catch  (Exception e) { 
             e.printStackTrace(); 
         }  finally  { 
             close(sta,con); 
         } 
         return  rows; 
     } 
      
     /** 
      * 关闭 → 注意关闭的顺序 rs,sta,con.   
      * @param rs 
      * @param sta 
      * @param con 
      */ 
     public  void  close(ResultSet rs, PreparedStatement sta, Connection con) { 
         try  { 
             if (rs !=  null ) { 
                 rs.close(); 
             } 
         }  catch  (SQLException e) { 
             e.printStackTrace(); 
         }  finally  { 
             try  { 
                 if (sta !=  null ) { 
                     sta.close(); 
                 } 
             }  catch  (SQLException e) { 
                 e.printStackTrace(); 
             }  finally  { 
                 try  { 
                     if (con !=  null ) { 
                         con.close();     
                     } 
                 }  catch  (SQLException e) { 
                     e.printStackTrace(); 
                 } 
             } 
         } 
     } 
     /** 
      * sta,con的关闭 
      * @param sta 
      * @param con 
      */ 
     public  void  close(PreparedStatement sta, Connection con) { 
         this .close( null , sta, con); 
     } 
     //************************************************ 
}

3.com.hanchao.dao包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package  com.hanchao.dao; 
  
import  java.sql.ResultSet; 
import  java.sql.SQLException; 
import  java.util.List; 
  
import  com.hanchao.entity.User; 
import  com.hanchao.util.DBHelp; 
import  com.hanchao.util.RowMapper; 
  
/** 
  * 对User对象操作的Dao类 
  * @author hanlw 
  * 2012-07-09 
  */ 
public  class  UserDao { 
  
     private  DBHelp<User> db =  new  DBHelp<User>(); 
      
     /** 
      * 添加操作 
      * @param name 
      * @param address 
      * @return 
      */ 
     public  int  save(String name, String address) { 
         String sql =  "insert into t_user(username,address) values(?,?)" ; 
         return  db.executeSQL(sql, name,address); 
     } 
      
     /** 
      * 更新操作 
      * @param user 
      * @return 
      */ 
     public  int  update(User user) { 
         String sql =  "update t_user set username=?,address=? where id=?" ; 
         return  db.executeSQL(sql, user.getUsername(),user.getAddress(),user.getId()); 
     } 
      
     /** 
      * 删除操作 
      * @param id 
      * @return 
      */ 
     public  int  delete( int  id) { 
         String sql =  "delete from t_user where id=?" ; 
         return  db.executeSQL(sql, id); 
     } 
      
     /** 
      * 查找单独的一个用户 
      * @param name 
      * @return 
      */ 
     public  User findByName(String name) { 
         String sql =  "select id,username,address from t_user where username=?" ; 
         return  db.queryForObject(sql,  new  UserRowMpper(), name); 
     } 
      
     /** 
      * 查询所有 
      * @return 
      */ 
     public  List<User> findAll() { 
         String sql =  "select id,username,address from t_user" ; 
         return  db.queryForList(sql,  new  UserRowMpper()); 
     } 
      
     /** 
      * 接口RowMapper的一个实现类  (这是一个内部类哦) 
      * 具体了解内部类的知识：http://hanchaohan.blog.51cto.com/2996417/930721 
      * @author hanlw 
      * 
      */ 
     private  class  UserRowMpper  implements  RowMapper<User> {  
         /** 
          * 实现该接口的所有的方法 
          */ 
         public  User mapperRow(ResultSet rs)  throws  SQLException { 
             User user =  new  User(); 
             user.setId(rs.getInt( "id" )); 
             user.setUsername(rs.getString( "username" )); 
             user.setAddress(rs.getString( "address" )); 
             return  user; 
         } 
          
     } 
}

4.com.hanchao.test包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package  com.hanchao.test; 
  
import  java.util.List; 
  
import  com.hanchao.dao.UserDao; 
import  com.hanchao.entity.User; 
  
/** 
  * 测试 
  * @author hanlw 
  * 2012-07-09 
  */ 
public  class  Test { 
  
     public  static  void  main(String[] args) { 
          
         /** 
          * 1.添加操作 
          */ 
         UserDao dao =  new  UserDao(); 
         dao.save( "tom" ,  "cherry" ); 
          
         /** 
          * 2.更新操作 
          */ 
         User user =  new  User(); 
         user.setId( 32 ); 
         user.setAddress( "" ); 
         user.setUsername( "chenchen" ); 
         dao.update(user); 
          
         /** 
          * 3.删除操作 
          */ 
         dao.delete( 31 ); 
          
         /** 
          * 4.查找一个对象 
          */ 
         User u = dao.findByName( "hanchao" ); 
         System.out.println( "----" +u.getAddress()); 
          
         /** 
          * 查找一个集合 
          */ 
         List<User> list = dao.findAll(); 
         for (User us : list) { 
             System.out.println(us.getUsername()); 
         } 
     } 
}

关于泛型，可以了解一下这篇文字：http://www.cnblogs.com/yinhaiming/articles/1749738.html


     本文转自韩立伟 51CTO博客，原文链接：http://blog.51cto.com/hanchaohan/930862，如需转载请自行联系原作者







XXL-JOB完全开发手册（一篇学会XXL-JOB所有知识点）
hao_kkkkk的专栏
03-19 2246
如果任务类型为 “GLUE模式”，将会加载 GLue 代码，实例化 Java 对象，注入依赖的 Spring 服务（注意：Glue代码中注入的Spring服务，必须存在与该“执行器”项目的Spring容器中），然后调用execute方法，执行任务逻辑。使用于业务复杂，业务量大，服务器多。​ 调度中心和执行器两个模块分开部署，相互分离，两者之间通过RPC进行通信，其中调度中心主要是提供一个平台，管理调度信息，发送调度请求，自己不承担业务代码，而执行器接受调度中心的调度执行业务逻辑。
Redis-全面详解（学习总结---从入门到深化）
12-08 1500
KV型NoSql顾名思义就是以键值对形式存储的非关系型数据库，是最简单、最容易理解也是大家最熟悉 的一种NoSql，因此比较快地带过。KV型NoSql最大的优点就是高性能，利用Redis自带的BenchMark做基准测试，TPS可达到10万的级别，性能非常强劲。名称、价格、出厂信息、生产厂商，商家信息等， 关系型数据库就可以解决。淘宝内部用的Mysql是里面的大牛自己改造过的。Redis是一个使用ANSI C编写的开源、包含多种数据结构、支持网络、基于内存、可选持久性的键值对存储数据库。
匿名内部类改造类结构
黎明
05-27 205
package com.liming.overload; public class OverLoadTest { public static void main(String[] args) { test("11"); test(1); new OverLoadTest(/*可调用构造方法*/){ //匿名内部类改...
匿名内部类与jdbc例子
rufus_123的博客
03-06 223
  package com.qingyuan.server; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import org.ju...
RowMapper是什么？怎么用？
热门推荐
JAVA菜鸟Fishsr的专栏
04-08 3万+
spring 中的 RowMapper sping中的RowMapper可以将数据中的每一行数据封装成用户定义的类. 我们在数据库查询中，如果返回的类型是用户自定义的类型(其实我们在数据库查询中大部分返回的都是自定义的类)则需要包装，如果是Java自定义的类型，如：String则不需要. 如果sping与hibernate 相结合了,基本上是用不到,大多数都是在spring单独
利用PreparedStatement进行增删改查！
mnshenyanping的专栏
08-06 1388
1 插入数据 public boolean ChaRu3(User user){ boolean flag=true; Connection conn=null; PreparedStatement ps=null; //创建PreparedStatement 对象 String sql= "insert into u
快速入门分库分表中间件 Sharding-JDBC
程序员高级码农的博客
03-11 1090
最早是当当网内部使用的一款分库分表框架，到2017年的时候才开始对外开源，这几年在大量社区贡献者的不断迭代下，功能也逐渐完善，现已更名为，2020年4⽉16⽇正式成为Apache软件基⾦会的顶级项⽬。随着版本的不断更迭的核心功能也变得多元化起来。从最开始 Sharding-JDBC 1.0 版本只有数据分片，到 Sharding-JDBC 2.0 版本开始支持数据库治理（注册中心、配置中心等等），再到 Sharding-JDBC 3.0版本又加分布式事务 （支持AtomikosNarayana。
从开发者角度看数据库架构进化史：JDBC - 中间件 - TiDB
TiDB 社区干货传送门
05-16 815
在业务开发早期，用 Java 借助 JDBC 进行数据库操作，虽能实现基本交互，但需手动管理连接、编写大量 SQL 及处理结果集，开发与维护成本高且易出错。随着业务发展，数据库表结构复杂，这种方式弊端凸显。为解决该问题，ORM 技术诞生。它将数据库表映射为 Java 类，使开发者能用面向对象方式操作数据库，提高开发效率、降低耦合度。 而企业级应用规模扩大、业务逻辑变复杂后，需要更有效的管理和组织。Spring 框架应运而生，它提供 IoC
SpringCloud学习笔记-狂神说
weixin_44202871的博客
07-17 730
SpringBoot 微服务
关于jdbc-util的封装
Invadery的博客
06-02 1022
－、jdbc的封装应该分为两层： 1.dao层［此层封装的是对数据库的操作 例如：增删改差 ］ 2.domain层［这是封装的数据库的对象，在传递数据的时候 一般都是传递对象］ ＝、dao层 1.在dao层里面我分为了两个文件 第一个：JdbcDao.java 第二个：JdbcUtil.java 从名字 相信也能知道是用来干嘛的了.... 三、JdbcDao.java［这
spring jdbc 的RowMapper
旅行才是人生追寻
10-29 2823
如果用spring 的jdbc肯定会使用RowMapper 这样queryforList返回的才是对象 那么这个rowMapper怎么写才可以重复利用呢 rs.getString(index)或者rs.getString(“name”) 如果没有这个值都会报错的，这样过少查询这个值这个rowMapper就不能重复利用了 但是如果我们只查询一个对象那个传入ParameterizedBean
javaweb项目
weixin_44441221的博客
01-07 298
1.dao包 （1）ProDao.java package dao; import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import entity.Pro; import util.RowMapper; import util.DBHelp; public class ProDao { ...
实例化的对象和引用...while(**.next()){实例化位置 、、***list.add（实例化的那个对象） }...
jeas_rt 的博客
09-17 210
public List&lt;NewsCategory&gt; getNewsCategoryList() { List&lt;NewsCategory&gt; newsCategoryList = new ArrayList&lt;NewsCategory&gt;(); String sql ="select * from news_category"; Object[] ...
使用SPRING 中ROWMAPPER
人生最遗憾的莫过于：轻易地放弃了不该放弃的,固执地坚持了不该坚持的
01-12 554
RowMapper可以将数据中的每一行封装成用户定义的类，在数据库查询中，如果返回的类型是用户自定义的类型则需要包装，如果是Java自定义的类型，如：String则不需要，Spring最新的类SimpleJdbcTemplate使用更加简单了。 下面这个实例说明了如何使用RowMapp，从网上下载的代码，还行能说明问题。在使用过程中我们可以将内部类做成POJO的外部类，只要实现RowMapper
性能测试工具JvisualVM/jconsole使用
最新发布
平时的经验总结，学习历程
09-12 215
port是jmx的另一个通信端口。可以不设置，启动后系统会自动随机指定端口。如果关闭了防火墙，没有网络访问策略，可以不设置。如果服务器需要开通端口访问策略此处需要配置开通策略的端口。然后在windows客户机，安装jdk目录下的bin目录下找到jvisualvm.exe或jconsole，通过远程连接方式监控jvm的cpu 内存 线程 类加载的情况。com.sun.management.jmxremote.port 是客户端连接的端口。主要介绍远程使用方式，在启动参数添加如下参数。
还在重启应用改 Topic？Spring Boot 动态 Kafka 消费的“终极形态”
郑龙飞
09-10 736
/ 用于存储 @KafkaListener 的“蓝图”// ... 可按需添加 concurrency, autoStartup 等其他属性(元数据采集与注册)@Component@OverrideClass<?= null &&!通过巧妙地结合和动态配置中心，我们实现了一个功能极其强大的动态 Kafka 消费管理方案。
【lucene】bitsetiterator
risc123456的博客
09-09 531
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
计算机毕设 java 高校饭堂点餐系统 基于微信小程序 + SSM 的高校餐饮服务平台 Java+MySQL 的点餐与运营系统
毕设源码伍学长
09-10 1020
在高校饭堂就餐需求增长的背景下，传统点餐依赖窗口排队、效率低，存在高峰期拥堵、菜品信息不透明等问题，难以满足师生便捷就餐需求。采用 Java 技术、SSM 框架、Uni-weixin 技术及 MySQL 数据库，开发高校饭堂点餐系统（微信小程序端 + 服务端），整合菜品展示、在线点餐、订单跟踪等功能，支持管理员、商家、用户三类角色协同，打造专业化餐饮服务平台。该系统既能帮助管理员监管平台内容，商家高效管理菜品与订单，又能让用户便捷查询菜品、完成点餐，提升高校饭堂服务效率与用户体验。
基于Eclipse MySQL的Java Web问卷调查系统改造教程
### 知识点详解 #### 1. Java Web技术栈 Java Web应用程序通常构建在企业级Java平台之上，涉及多种技术和组件。这个调查问卷系统是基于...通过实践这个系统的改造和使用，学习者可以更好地掌握Java Web开发的精髓。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值