Java数据库连接大全-基础版
JDBC
不废话了直接上封装好的类你拿去用就行了
maven
复制代码
1
2
3
4
5
6<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency>
加载驱动
Class.forName(“com.mysql.jdbc.Driver”);
Connection connection=DriverManager.getConnection(“jdbc:mysql://localhost:3306/myschool”,“root”,“root”);
System.out.println(“建立连接成功”);
说明
jdbc:mysql: 是默认的 根据你使用的数据库类型 而不同
localhost:3306/myschool 是链接地址 和 数据库
在实际开发中为了避免数据库 乱码 就需要指定数据库 将编码指定为 utf-8
localhost:3306/myschool?useUnicode=true&charactetEncoding=utf-8
“root”,“root” 第一是用户 第二个是密码
connection.close();
System.out.println(“关闭连接”);
以上代码看看就行了 下面是完全版
Statement接口 和 PreparedStatement接口 ,但是Statement有sql注入风险所以 我们使用PreparedStatement接口中的方法,
创建配置文件database.properties
复制代码
1
2
3
4
5driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false username=root password=root
注意这个: ?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false 特别重要
useUnicode 指定以Unicode编码格式
是否使用Unicode字符集，如果参数characterEncoding设置为gb2312或gbk或者utf8，本参数值必须设置为true
characterEncoding 指定编码类型
autoReconnect 是否使用针对数据库连接池的重连策略
failOverReadOnly 自动重连成功后，连接是否设置为只读？
创建JDBC_Util工具类 支持并发编程无需同步(牺牲一点内存,增加速度)
复制代码
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225package cn.htsa.www.dao; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.sql.PreparedStatement; import java.sql.ResultSet; //可以实现多线程并发操作 public class JDBC_Util { private static final ThreadLocal<ResultSet> resultSet=new ThreadLocal<ResultSet>(){ @Override protected ResultSet initialValue() { return super.initialValue(); } }; private static final ThreadLocal<PreparedStatement> prepareStatement=new ThreadLocal<PreparedStatement>(){ @Override protected PreparedStatement initialValue() { return super.initialValue(); } }; private static final ThreadLocal<Connection> connection=new ThreadLocal<Connection>(){ @Override protected Connection initialValue() { Connection connection=null; Properties properties=new Properties(); InputStream is= JDBC_Util.class.getClassLoader().getResourceAsStream("database.properties"); try { properties.load(is); } catch (IOException e) { e.printStackTrace(); } try { Class.forName(properties.getProperty("driver")); } catch (ClassNotFoundException e) { e.printStackTrace(); } try { connection=DriverManager.getConnection(properties.getProperty("url"),properties.getProperty("username"),properties.getProperty("password")); } catch (SQLException e) { e.printStackTrace(); } return connection; } }; //事务增删改 public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString,List<Object[]> objects) { int num=0; List<PreparedStatement> preparedStatements = null; if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){ System.out.println("集合不能为空"); try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } try { preparedStatements = new ArrayList<PreparedStatement>(); for (int i = 0; i < sqlString.size(); i++) { if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){ System.out.println("sql语句 和 参数 不能为空"); try { prepareStatement.get().close(); connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } prepareStatement.set(connection.get().prepareStatement(sqlString.get(i))); for (int j = 0; j < objects.get(i).length; j++) { prepareStatement.get().setObject(j+1, objects.get(i)[j]); } preparedStatements.add(prepareStatement.get()); } connection.get().setAutoCommit(false); for (int i = 0; i <preparedStatements.size(); i++) { num+=preparedStatements.get(i).executeUpdate(); } System.out.println("提交成功"); connection.get().commit(); } catch (SQLException e) { e.printStackTrace(); try { System.out.println("执行事务异常--回滚数据"); connection.get().rollback(); num=0; } catch (SQLException e1) { e1.printStackTrace(); } }finally{ try { connection.get().setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } closeAll();//释放连接 } return num; } //不加事务的增删改 public static int INSERT_DELETE_UPDATE(String sqlString,Object[] objects){ int num=0; try { prepareStatement.set(connection.get().prepareStatement(sqlString)); if(objects!=null){ for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i+1, objects[i]); } } num= prepareStatement.get().executeUpdate(); } catch (SQLException e) { e.printStackTrace(); }finally{ closeAll();//释放连接 } return num; } //查询 返回 ResultSet对象 public static ResultSet SELECT(String sqlString,Object[] objects){ try { prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString)); if(objects!=null){ for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i+1, objects[i]); } } resultSet.set(prepareStatement.get().executeQuery()); } catch (SQLException e) { e.printStackTrace(); } return resultSet.get(); } //关闭数据库连接 内部方法 public static void closeAll(){ if(resultSet.get()!=null){ try { resultSet.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if(prepareStatement.get()!=null){ try { prepareStatement.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if(connection.get()!=null){ try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } } resultSet.remove(); prepareStatement.remove(); connection.remove(); } }
以上代码没有加日志 如果 需要自行添加 还有就是里面的参数你也可以自己修改成可变参数 根据爱好 自己看着改就行了 也不难
使用教程 简单的演示一下
查询
复制代码
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//不带条件的 @Test public void show1(){ String sql="select * from books"; ResultSet select = JDBC_Util.SELECT(sql, null); try { while (select.next()){ System.out.print(select.getInt(1)); System.out.print(select.getString(2)); System.out.println(select.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_Util.closeAll(); } } //带条件的 @Test public void show2(){ String sql1="select * from books where id=? and price>?"; Object[] object={1,30}; ResultSet select1 = JDBC_Util.SELECT(sql1, object); try { while (select1.next()){ System.out.print(select1.getInt("id")); System.out.print(select1.getString("name")); System.out.println(select.getDouble("price")); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_Util.closeAll(); } }
注意 如果使用 下标来获取 对应字段的值 下标的位置从1开始
也就是1=第一个字段 (是查询出来的结果 第一个 从左边开始)
增删改
只演示一个 删除 其他的都一样
复制代码
1
2
3
4
5
6
7
8
9
10
11
12@Test public void show3(){ String sql="delete from books where id=?"; Object[] objects={1}; int i = JDBC_Util.INSERT_DELETE_UPDATE(sql, objects); if (i>0){ System.out.println("删除成功"); } } //无需关闭连接 在工具类中帮你关闭了
事务的用法
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21@Test public void show4(){ List<String> list=new ArrayList<>(); String sql="delete from books where id=?"; String sql1="delete from books where id_1=?"; list.add(sql); list.add(sql1); List<Object[]> list_obj=new ArrayList<>(); Object[] objects={5}; Object[] objects1={4}; list_obj.add(objects); list_obj.add(objects1); int i = JDBC_Util.transaction_INSERT_DELECT_UPDATE(list,list_obj); if (i>=1){ System.out.println("删除成功"); }else { System.out.println("删除失败"); } }
注意事项
注意: ? 不能作用于 列 只能作用于条件和值 否则 编译异常
比如select ?,?from 表 就会报错
select * from 表 where 列=? 这就可以
或者 insert into表 values(?,?,?,?) 也可以
添加数据时候 自增列使用default
还有?周围不要加 ’ ’ 符号 否则解析不出来
使用模糊查询 这种情况也解析不出来 “%” +id+ “%” 只能在传值之前的时候给他补上Object[] object3={"%"+"abc"+"%"};
JDBC调用存储过程/存储函数
需要的配置
复制代码
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// 数据库驱动 public static final String DRIVER_CLASS = "com.mysql.cj.jdbc.Driver"; // 数据库连接地址 public static final String DB_URL = "jdbc:mysql://localhost:3306/voidme?serverTimezone=Hongkong&useUnicode=true&characterEncoding=utf8&useSSL=false"; // 数据库用户名称 public static final String DB_USER = "root"; // 数据库用户密码 public static final String DB_PASSWORD = "root"; /** * 获取数据库连接 * * @author pan_junbiao * @return 数据库连接对象 */ public static Connection getConnection() { Connection conn = null; try { // 加载数据库驱动类 Class.forName(DRIVER_CLASS); System.out.println("数据库驱动加载成功"); // 获取数据库连接对象 conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD); System.out.println("数据库连接成功"); } catch (ClassNotFoundException cnfe) { cnfe.printStackTrace(); } catch (SQLException sqle) { sqle.printStackTrace(); } catch (Exception ex) { ex.printStackTrace(); } return conn; } /** * 关闭数据库操作对象 * * @author pan_junbiao * @param res ResultSet对象 * @param stmt Statement对象 * @param conn Connection对象 */ public static void closeOperate(ResultSet res, Statement stmt, Connection conn) { try { // 关闭ResultSet对象 if (res != null) { res.close(); } // 关闭Statement对象 if (stmt != null) { stmt.close(); } // 关闭Connection对象 if (conn != null) { conn.close(); } System.out.println("关闭数据库操作对象完成"); } catch (SQLException sqle) { sqle.printStackTrace(); } }
存储过程sql代码
复制代码
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-- 存储过程：分页查询用户列表 -- 输入参数：page_index：当前页码 -- 输入参数：page_size：分页大小 -- 输出参数：total_count：数据总数 -- 输出参数：total_page：总页数 DROP PROCEDURE IF EXISTS proc_search_user; CREATE PROCEDURE proc_search_user(IN page_index INT,IN page_size INT, OUT total_count INT, OUT total_page INT) BEGIN DECLARE begin_no INT; SET begin_no = (page_index-1)*page_size; -- 起始页 -- 分页查询列表 SELECT * FROM t_user WHERE id >= ( SELECT id FROM t_user -- 优化查询直接获取起始位置 ORDER BY id ASC LIMIT begin_no,1 ) ORDER BY id ASC LIMIT page_size; -- 结束位置 -- 计算数据总数 SELECT COUNT(*) INTO total_count FROM t_user; -- 计算总页数 SET total_page = FLOOR((total_count + page_size - 1) / page_size); END; SET @total_count=0; SET @total_page=0; CALL proc_search_user(1,5,@total_count,@total_page) SELECT @total_count as 数据总数 , @total_page as 总页数
存储函数sql代码
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20-- 存储函数：根据用户编号，获取用户姓名 -- 输入参数：用户编号 -- 返回结果：用户姓名 DROP FUNCTION IF EXISTS func_get_user_name; CREATE FUNCTION func_get_user_name(in_id INT) RETURNS VARCHAR(30) BEGIN DECLARE out_name VARCHAR(30); SELECT name INTO out_name FROM t_user WHERE id = in_id; RETURN out_name; END; SELECT func_get_user_name(6) as 名称
复制代码
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/** * 调用存储过程 * * @author pan_junbiao */ public static void execProcedure(String sql) { Connection conn = null; // 数据库连接对象 CallableStatement clbStmt = null; // CallableStatement对象 ResultSet res = null; // 结果集对象 try { // 获取数据库连接 conn = getConnection(); // 创建CallableStatement对象 {CALL proc_search_user(?,?,?,?)} clbStmt = conn.prepareCall(sql); // 设置输入参数 clbStmt.setInt(1, 2); // 查询第2页数据 clbStmt.setInt(2, 5); // 每页5条数据 // 注册输出参数 (out) clbStmt.registerOutParameter(3, Types.INTEGER); clbStmt.registerOutParameter(4, Types.INTEGER); // 执行调用存储过程，并获取结果集 res = clbStmt.executeQuery(); // 循环遍历结果集 while (res.next()) { // 获取列值 int id = res.getInt("id"); // 输出列值 System.out.println("编号：" + id); } // 获取输出参数值 int totalCount = clbStmt.getInt(3); int totalPage = clbStmt.getInt(4); System.out.println("数据总数：" + totalCount + " 总页数：" + totalPage); } catch (SQLException sqle) { sqle.printStackTrace(); } finally { // 关闭数据库操作对象 closeOperate(res, clbStmt, conn); } } /** * 调用存储函数,实际中还可以是SELECT 代替 * * @author pan_junbiao */ public static void execFunction(String sql) { Connection conn = null; // 数据库连接对象 CallableStatement clbStmt = null; // CallableStatement对象 try { // 获取数据库连接 conn = getConnection(); // 创建CallableStatement对象 {?=CALL func_get_user_name(?)} clbStmt = conn.prepareCall(sql); // 设置输出结果参数 ? 是站位符 第一个? clbStmt.registerOutParameter(1, Types.VARCHAR); // 设置输入参数 第二个?号 clbStmt.setInt(2, 6); // 执行调用存储函数 clbStmt.execute(); // 获取输出参数值 String userName = clbStmt.getString(1); System.out.println("用户名称：" + userName); } catch (SQLException sqle) { sqle.printStackTrace(); } finally { // 关闭数据库操作对象 closeOperate(null, clbStmt, conn); } } public static void main(String[] args) { // execProcedure("{CALL proc_search_user(?,?,?,?)}"); //调用存储过程 execFunction("{?=CALL func_get_user_name(?)}");//调用存储函数 }
连接池
什么是连接池?
连接，是我们的编程语言与数据库交互的一种方式。我们经常会听到这么一句话“数据库连接很昂贵“。
有人接受这种说法，却不知道它的真正含义。因此，下面我将解释它究竟是什么。[如果你已经知道了，你可以跳到它的工作原理部分]
创建连接的代码片段：
复制代码
1
2
3Class.forName("com.mysql.jdbc.Driver"); 2.Connection connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool","root","root");
当我们创建了一个Connection对象，它在内部都执行了什么：
1.“DriverManager”检查并注册驱动程序，
2.“com.mysql.jdbc.Driver”就是我们注册了的驱动程序，它会在驱动程序类中调用getConnection方法。
3.com.mysql.jdbc.Driver的getConnection方法根据我们请求的“字符串”，创建一个“Socket连接”，连接到IP为“localhost”，默认端口3306的myschool数据库。
4.创建的Socket连接将被用来查询我们指定的数据库，并最终让程序返回得到一个结果。
为什么昂贵？
现在让我们谈谈为什么说它“昂贵“。
如果创建Socket连接花费的时间比实际的执行查询的操作所花费的时间还要更长。
这就是我们所说的“数据库连接很昂贵”，因为连接资源数是1，它需要每次创建一个Socket连接来访问数据库。
因此，我们将使用连接池。
连接池初始化时创建一定数量的连接，然后从连接池中重用连接，而不是每次创建一个新的。
使用c3p0连接池
需要的依赖
c3p0-0.9.5.2.jar
http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&filename=c3p0-0.9.5.2.jar
mchange-commons-java-0.2.12.jar
http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&filename=mchange-commons-java-0.2.12.jar
mysql-connector-java-5.1.0-bin.jar
http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&filename=mysql-connector-java-5.1.0-bin.jar
如果点不开(可能解析问题) 直接复制链接到 游览器URL上
Maven
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16<dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5.2</version> </dependency> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.4</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency>
配置文件名称c3p0-config.xml (必须是这个名称)
复制代码
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<?xml version="1.0" encoding="UTF-8"?> <c3p0-config> <!-- 默认配置信息 default --> <default-config> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property> <property name="user">root</property> <property name="password">root</property> <!-- 连接池 初始化的时候 有多少个连接数量--> <property name="initialPoolSize">10</property> <!-- 最大连接数量 也就是当连接的用户同时达到100以上那么就报错了--> <property name="maxPoolSize">100</property> </default-config> <!-- 也可以指定使用下面的配置信息 (也就是多一个选择)--> <named-config name="intergalactoApp"> <property name="driverClass">com.mysql.jdbc.Driver</property> <property name="jdbcUrl">jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false</property> <property name="user">root</property> <property name="password">root</property> <!-- 连接池 第一次创建多少个 连接对象--> <property name="initialPoolSize">10</property> <!-- 最大连接数量 也就是当连接的用户同时达到100以上那么就报错了--> <property name="maxPoolSize">100</property> </named-config> <!-- 可以定义多个 named-config --> </c3p0-config>
工具类JDBC_c3p0_Util 支持并发编程无需同步(牺牲一点内存,增加速度)
复制代码
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215package cn.htsa.www.dao; import com.mchange.v2.c3p0.ComboPooledDataSource; import javax.sql.DataSource; 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 JDBC_c3p0_Util { private static final ThreadLocal<Connection> connection = new ThreadLocal<Connection>() { @Override protected Connection initialValue() { Connection connection = null; //使用默认的 <default-config> //DataSource ds=new ComboPooledDataSource(); //还可以使用 非默认的 <named-config name=" "> //获取配置文件中的数据 DataSource ds1 = new ComboPooledDataSource("intergalactoApp"); try { connection = ds1.getConnection(); //返回Connection对象 System.out.println("aaa" + connection); } catch (SQLException e) { e.printStackTrace(); } return connection; } }; private static final ThreadLocal<ResultSet> resultSet = new ThreadLocal<ResultSet>() { @Override protected ResultSet initialValue() { return super.initialValue(); } }; private static final ThreadLocal<PreparedStatement> prepareStatement = new ThreadLocal<PreparedStatement>() { @Override protected PreparedStatement initialValue() { return super.initialValue(); } }; //事务增删改 public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) { int num = 0; List<PreparedStatement> preparedStatements = null; if (sqlString == null || objects == null || sqlString.size() == 0 || objects.size() == 0) { System.out.println("集合不能为空"); try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } try { preparedStatements = new ArrayList<PreparedStatement>(); for (int i = 0; i < sqlString.size(); i++) { if (sqlString.get(i).trim().length() == 0 || sqlString.get(i) == null && objects.get(i) == null || objects.get(i).length == 0) { System.out.println("sql语句 和 参数 不能为空"); try { prepareStatement.get().close(); connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString.get(i))); for (int j = 0; j < objects.get(i).length; j++) { prepareStatement.get().setObject(j + 1, objects.get(i)[j]); } preparedStatements.add(prepareStatement.get()); } connection.get().setAutoCommit(false); for (int i = 0; i < preparedStatements.size(); i++) { num += preparedStatements.get(i).executeUpdate(); } System.out.println("提交成功"); connection.get().commit(); } catch (SQLException e) { e.printStackTrace(); try { System.out.println("执行事务异常--回滚数据"); connection.get().rollback(); num = 0; } catch (SQLException e1) { e1.printStackTrace(); } } finally { try { connection.get().setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } closeAll();//释放连接 } return num; } //不加事务的增删改 public static int INSERT_DELETE_UPDATE(String sqlString, Object[] objects) { int num = 0; try { prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString)); if (objects != null) { for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i + 1, objects[i]); } } num = prepareStatement.get().executeUpdate(); } catch (SQLException e) { e.printStackTrace(); } finally { closeAll();//释放连接 } return num; } //查询 返回 ResultSet对象 public static ResultSet SELECT(String sqlString, Object[] objects) { try { prepareStatement.set(connection.get().prepareStatement(sqlString)); if (objects != null) { for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i + 1, objects[i]); } } resultSet.set(prepareStatement.get().executeQuery()); } catch (SQLException e) { e.printStackTrace(); } return resultSet.get(); } //关闭数据库连接 内部方法 public static void closeAll() { if (resultSet.get() != null) { try { resultSet.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if (prepareStatement.get() != null) { try { prepareStatement.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if (connection.get() != null) { try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } } resultSet.remove(); prepareStatement.remove(); connection.remove(); } }
使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_c3p0_Util)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17@Test public void show1(){ String sql="select * from books"; ResultSet select = JDBC_c3p0_Util.SELECT(sql, null); try { while (select.next()){ System.out.print(select.getInt(1)); System.out.print(select.getString(2)); System.out.println(select.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_Util.closeAll(); } }
使用druid连接池(常用)
需要的依赖
druid-1.0.9.jar
mysql-connector-java-5.1.0-bin.jar
maven
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15<!--java druid 连接--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.12</version> </dependency> <!--java JDBC--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency>
配置文件druid.properties
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false username=root password=root # 初始化连接数量 initialSize=5 #最小空闲连接 minIdle=3 # 最大连接数 maxActive=10 # 最大超时时间 3秒 maxWait=3000
工具类JDBC_druid_Util 支持并发编程无需同步(牺牲一点内存,增加速度)
复制代码
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219package cn.htsa.www.dao; import cn.htsa.www.test.test; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Properties; import java.sql.PreparedStatement; import java.sql.ResultSet; public class JDBC_druid_Util { private static final ThreadLocal<ResultSet> resultSet=new ThreadLocal<ResultSet>(){ @Override protected ResultSet initialValue() { return super.initialValue(); } }; private static final ThreadLocal<PreparedStatement> prepareStatement=new ThreadLocal<PreparedStatement>(){ @Override protected PreparedStatement initialValue() { return super.initialValue(); } }; private static final ThreadLocal<Connection> connection=new ThreadLocal<Connection>(){ @Override protected Connection initialValue() { Connection connection=null; //1.创建一个Propertis 集合 Properties pro=new Properties(); try { pro.load(test.class.getClassLoader().getResourceAsStream("druid.properties")); } catch (IOException e) { e.printStackTrace(); } //创建一个DataSource try { DataSource ds= DruidDataSourceFactory.createDataSource(pro); connection=ds.getConnection(); } catch (Exception e) { e.printStackTrace(); } return connection; } }; //事务增删改 public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString,List<Object[]> objects) { int num=0; List<PreparedStatement> preparedStatements = null; if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){ System.out.println("集合不能为空"); try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } try { preparedStatements = new ArrayList<PreparedStatement>(); for (int i = 0; i < sqlString.size(); i++) { if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){ System.out.println("sql语句 和 参数 不能为空"); try { prepareStatement.get().close(); connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } prepareStatement.set(connection.get().prepareStatement(sqlString.get(i))); for (int j = 0; j < objects.get(i).length; j++) { prepareStatement.get().setObject(j+1, objects.get(i)[j]); } preparedStatements.add(prepareStatement.get()); } connection.get().setAutoCommit(false); for (int i = 0; i <preparedStatements.size(); i++) { num+=preparedStatements.get(i).executeUpdate(); } System.out.println("提交成功"); connection.get().commit(); } catch (SQLException e) { e.printStackTrace(); try { System.out.println("执行事务异常--回滚数据"); connection.get().rollback(); num=0; } catch (SQLException e1) { e1.printStackTrace(); } }finally{ try { connection.get().setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } closeAll();//释放连接 } return num; } //不加事务的增删改 public static int INSERT_DELETE_UPDATE(String sqlString,Object[] objects){ int num=0; try { prepareStatement.set(connection.get().prepareStatement(sqlString)); if(objects!=null){ for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i+1, objects[i]); } } num= prepareStatement.get().executeUpdate(); } catch (SQLException e) { e.printStackTrace(); }finally{ closeAll();//释放连接 } return num; } //查询 返回 ResultSet对象 public static ResultSet SELECT(String sqlString,Object[] objects){ try { prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString)); if(objects!=null){ for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i+1, objects[i]); } } resultSet.set(prepareStatement.get().executeQuery()); } catch (SQLException e) { e.printStackTrace(); } return resultSet.get(); } //关闭数据库连接 内部方法 public static void closeAll(){ if(resultSet.get()!=null){ try { resultSet.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if(prepareStatement.get()!=null){ try { prepareStatement.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if(connection.get()!=null){ try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } } resultSet.remove(); prepareStatement.remove(); connection.remove(); } }
使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_druid_Util)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17@Test public void show1(){ String sql="select * from books"; ResultSet select = JDBC_druid_Util.SELECT(sql, null); try { while (select.next()){ System.out.print(select.getInt(1)); System.out.print(select.getString(2)); System.out.println(select.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_Util.closeAll; } }
使用DBCP连接池
需要的依赖在Tomcat里基本都有 一般使用IDEA都会默认给你导入
你就需要导入一个
mysql-connector-java-5.1.0-bin.jar
http://download.huitoushian.cn/index.jsp?path=D%3Awwwrootdoc.huitoushian.cnjar&filename=mchange-commons-java-0.2.12.jar
如果点不开(可能解析问题) 直接复制链接到 游览器URL上
maven
复制代码
1
2
3
4
5
6<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency>
DBCP主要就是用语在Tomcat中搭建连接池的(如果没有启动Tomcat服务器是无法使用的) ,当然使用上面的连接池也可以看你自己
而且只能在jsp 和Servlet 这二个地方使用 也就是服务端 不能直接在本地测试
在自己项目webapp下META-INF目录(没有就创建)下context.xml 文件
或者Tomcat安装目录下面conf目录下的 context.xml(如果,没用就 只能在自己项目中创建了)
在项目
context.xml文件内容
复制代码
1
2
3
4
5
6
7
8
9<Context> <Resource name="jdbc/news" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="10000" username="root" password="root" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false" /> </Context>
context.xml 内容 解析
name 是Resource标签 名称
auth 是 有两个属性 一个 是Container 由容器创建Resource 第二个是Application由web应用创建和管理Resource
type 是Resource 所属的类型
maxActive 活动状态下 最大同时连接数量 (正在连接还在使用中 )
maxIdle 空闲连接最大数量 (使用连接完成 现在连接处于空闲状态的 最大 数量)
maxWait 指定连接的最大空闲时间 毫秒
username 代表数据库 账户
password 代表密码
driverClassName 代表jdbc连接驱动
url 连接数据库 字符
jdbc:mysql 是Mysql数据库
127.0.0.1 和localhost都是一样的连接本地
test 数据库名称
useUnicode=true&characterEncoding=utf-8" 是字符编码
(当正在使用的连接超过了 空闲连接(maxIdle)的最大数量,就会创建新连接但是不能超过最大连接数量(maxActive) 当新创建的连接使用完毕后 处于空闲连接状态,在一定的连接空闲期间未被在次使用 就会被释放连接 ,空闲连接数量不能超过最大空闲连接的多余的就会被释放连接 ) 空闲最大连接<最大连接数量
比如: 当前连接 40人 最大连接数量50 最大空闲连接30 最大空闲时间10秒
40-30=10; 这多出的10人就不在 最大空连接的范围内 属于 溢出创建的连接 当用户使用完后就会 在空闲连接时间后 释放连接 直到空闲连接小于等于30
在比如: 打电话10086 日常可维持 在30个人 同时打电话 最大不能超过100
否则 其他人就需要进行等待 等 这100个人中其中 某些人打完 其他人才能 打进去电话 否则就会提示正在忙碌中请稍后在播
如果只有 10个人同时打 剩下的20个客服就处于空闲状态
如果忙碌时间 同时 有40个打电话 那么就需要在加上10个临时客服 等通话结束后
这加上来的10个客服 就要撤走
最大可同时100 也就是 忙碌的时候 在原有的基础上 在加70个临时客服 等空闲的时候在撤走
在自己项目webapp下WEB-INF目录下web.xml 文件 修改
或者Tomcat安装目录下面conf目录下的web.xml (如果,没用就 只能在自己项目中创建了)
web.xml 文件内容
复制代码
1
2
3
4
5
6
7
8
9
10
11
12<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0"> <resource-ref> <res-ref-name>jdbc/news</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth> </resource-ref> </web-app>
文本中的<resource-ref>标签内的这些参数必须 对应context.xml 文件内Resource 的参数否则就会创建数据库连接池失败
工具类JDBC_DBCP_Util 支持并发编程无需同步(牺牲一点内存,增加速度)
复制代码
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import javax.sql.DataSource; 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 JDBC_DBCP_Util { private static final ThreadLocal<ResultSet> resultSet = new ThreadLocal<ResultSet>() { @Override protected ResultSet initialValue() { return super.initialValue(); } }; private static final ThreadLocal<PreparedStatement> prepareStatement = new ThreadLocal<PreparedStatement>() { @Override protected PreparedStatement initialValue() { return super.initialValue(); } }; private static final ThreadLocal<Connection> connection = new ThreadLocal<Connection>() { @Override protected Connection initialValue() { Connection connection = null; try { //获取与逻辑名相关联的数据源对象 Context ctx = new InitialContext(); DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/news"); connection = ds.getConnection(); //通过web.xml文件内jdbc/news名称获取conntext.xml文件内的连接数据 } catch (SQLException | NamingException exception) { exception.printStackTrace(); } return connection; } }; //事务增删改 public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) { int num = 0; List<PreparedStatement> preparedStatements = null; if (sqlString == null || objects == null || sqlString.size() == 0 || objects.size() == 0) { System.out.println("集合不能为空"); try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } try { preparedStatements = new ArrayList<PreparedStatement>(); for (int i = 0; i < sqlString.size(); i++) { if (sqlString.get(i).trim().length() == 0 || sqlString.get(i) == null && objects.get(i) == null || objects.get(i).length == 0) { System.out.println("sql语句 和 参数 不能为空"); try { prepareStatement.get().close(); connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } return num; } prepareStatement.set(connection.get().prepareStatement(sqlString.get(i))); for (int j = 0; j < objects.get(i).length; j++) { prepareStatement.get().setObject(j + 1, objects.get(i)[j]); } preparedStatements.add(prepareStatement.get()); } connection.get().setAutoCommit(false); for (int i = 0; i < preparedStatements.size(); i++) { num += preparedStatements.get(i).executeUpdate(); } System.out.println("提交成功"); connection.get().commit(); } catch (SQLException e) { e.printStackTrace(); try { System.out.println("执行事务异常--回滚数据"); connection.get().rollback(); num = 0; } catch (SQLException e1) { e1.printStackTrace(); } } finally { try { connection.get().setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } closeAll();//释放连接 } return num; } //不加事务的增删改 public static int INSERT_DELETE_UPDATE(String sqlString, Object[] objects) { int num = 0; try { prepareStatement.set(connection.get().prepareStatement(sqlString)); if (objects != null) { for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i + 1, objects[i]); } } num = prepareStatement.get().executeUpdate(); } catch (SQLException e) { e.printStackTrace(); } finally { closeAll();//释放连接 } return num; } //查询 返回 ResultSet对象 public static ResultSet SELECT(String sqlString, Object[] objects) { try { prepareStatement.set((PreparedStatement) connection.get().prepareStatement(sqlString)); if (objects != null) { for (int i = 0; i < objects.length; i++) { prepareStatement.get().setObject(i + 1, objects[i]); } } resultSet.set(prepareStatement.get().executeQuery()); } catch (SQLException e) { e.printStackTrace(); } return resultSet.get(); } //关闭数据库连接 内部方法 public static void closeAll() { if (resultSet.get() != null) { try { resultSet.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if (prepareStatement.get() != null) { try { prepareStatement.get().close(); } catch (SQLException e) { e.printStackTrace(); } } if (connection.get() != null) { try { connection.get().close(); } catch (SQLException e) { e.printStackTrace(); } } resultSet.remove(); prepareStatement.remove(); connection.remove(); } }
使用方请参考JDBC工具类的使用 没什么区别 就是把调用的类名换了 (JDBC_DBCP_Util)
jsp页面
复制代码
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<%@ page import="java.sql.ResultSet" %> <%@ page import="java.sql.SQLException" %> <%@ page import="cn.htsa.www.dao.JDBC_DBCP_Util" %> <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> <% String sql="select * from books"; ResultSet select = JDBC_DBCP_Util.SELECT(sql, null); try { while (select.next()){ System.out.print(select.getInt(1)); System.out.print(select.getString(2)); System.out.println(select.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_DBCP_Util.closeAll(); } %> </body> </html>
Servlet
复制代码
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
41import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.sql.ResultSet; import java.sql.SQLException; @WebServlet(name = "Servlet") public class Servlet extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request,response); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //设置 请求 和响应 的格式都是 utf-8 request.setCharacterEncoding("utf-8"); response.setCharacterEncoding("utf-8"); //告诉游览器 要用utf-8来解析 response.setContentType("text/html; charset=utf-8"); String sql="select * from books"; ResultSet select = JDBC_DBCP_Util.SELECT(sql, null); try { while (select.next()){ System.out.print(select.getInt(1)); System.out.print(select.getString(2)); System.out.println(select.getDouble(3)); } } catch (SQLException e) { e.printStackTrace(); }finally { JDBC_DBCP_Util.close(select); } } }
jdbc-Template(推荐)
需要使用的依赖 maven
复制代码
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<dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.1.3</version> </dependency> <!--java druid 连接--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.12</version> </dependency> <!--java JDBC--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.10</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.2.5.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.2.5.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.5.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.2.5.RELEASE</version> </dependency>
jdbcTemp 是基于jdbc进行封装的
拥有了实体类自动映射的功能和映射List,Map,等功能非常强大
添加druid.properties配置文件 上面有
添加工具类Jdbc_Template
我使用的是druid连接池来完成的jdbc_template工具类 支持并发编程无需同步
基础配置
复制代码
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
138import com.alibaba.druid.pool.DruidDataSourceFactory; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DataSourceUtils; import javax.sql.DataSource; import java.io.IOException; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.Properties; public class Jdbc_Template { public static JdbcTemplate JdbcTemp=null; private static DataSource dataSource=null; //调用properties 文件的 数据库连接 static { //1.创建一个Propertis 集合 Properties pro=new Properties(); try { pro.load(Jdbc_Template.class.getClassLoader().getResourceAsStream("druid.properties")); } catch (IOException e) { e.printStackTrace(); } //创建一个DataSource try { dataSource= DruidDataSourceFactory.createDataSource(pro); JdbcTemp=new JdbcTemplate((DataSource) dataSource); } catch (Exception e) { e.printStackTrace(); } //不用 管连接的创建 因为 JdbcTemplate 他内部 会自动给你 创建 和关闭的 //除非 你手动 去调用 Connection } private static Connection Connec(){ return DataSourceUtils.getConnection(dataSource); } public static int transaction_INSERT_DELECT_UPDATE(List<String> sqlString, List<Object[]> objects) { Connection connection= Connec(); PreparedStatement prepareStatement=null; List<PreparedStatement> preparedStatements = null; int num=0; if(sqlString==null||objects==null||sqlString.size()==0||objects.size()==0){ System.out.println("集合不能为空"); try { connection.close(); } catch (SQLException e) { e.printStackTrace(); } return num; } try { preparedStatements = new ArrayList<PreparedStatement>(); for (int i = 0; i < sqlString.size(); i++) { if (sqlString.get(i).trim().length() == 0 ||sqlString.get(i)==null &&objects.get(i)==null||objects.get(i).length==0){ System.out.println("sql语句 和 参数 不能为空"); try { prepareStatement.close(); connection.close(); } catch (SQLException e) { e.printStackTrace(); } return num; } prepareStatement=(PreparedStatement) connection.prepareStatement(sqlString.get(i)); for (int j = 0; j < objects.get(i).length; j++) { prepareStatement.setObject(j+1, objects.get(i)[j]); } preparedStatements.add(prepareStatement); } connection.setAutoCommit(false); } catch (SQLException e) { e.printStackTrace(); } try { for (int i = 0; i <preparedStatements.size(); i++) { num+=preparedStatements.get(i).executeUpdate(); } System.out.println("提交成功"); connection.commit(); } catch (SQLException e) { e.printStackTrace(); try { System.out.println("执行事务异常--回滚数据"); connection.rollback(); num=0; } catch (SQLException e1) { e1.printStackTrace(); } }finally{ try { connection.setAutoCommit(true); } catch (SQLException e) { e.printStackTrace(); } try { prepareStatement.close(); connection.close(); } catch (SQLException e) { e.printStackTrace(); } } return num; } }
增删改
都是调用update() 这个方法 第二个参数是可变参数 能直接传Object[]
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20//添加 String sql = "insert into xinwen VALUES(default,?,?,?)"; //上面?号 对应下面的参数 int num= Jdbc_Template.JdbcTemp.update(sql,"尼玛安安1","哪啊2","2019-01-02"); System.out.println(num); //修改 String sql = "update xinwen set title=? where id=?"; //上面?号 对应下面的参数 int num= Jdbc_Template.JdbcTemp.update(sql,"哈洗车12","2"); System.out.println(num); //删除 String sql = "delete from xinwen where id=?"; //上面?号 对应下面的参数 int num= Jdbc_Template.JdbcTemp.update(sql,"1"); System.out.println(num);
查询
查询就不一样了
单条数据 Map<String,Object> queryForMap(sql , …)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17public Map<String,Object> update_show(String name) { //查询 String sql = "select * from day_1 where name =?"; //上面?号 对应下面的参数 Map<String,Object> map= null; try { map = Jdbc_Template.JdbcTemp.queryForMap(sql,name); } catch (DataAccessException e) { e.printStackTrace(); } return map; } //map内 : key 对应的 字段 value 对应 值 //如果查询不到 就会报错将程序停了 所以最好 用 异常检查
多条查询: List<Map<String,Object>> queryForList(sql , …)
复制代码
1
2
3
4
5
6
7List<Map<String,Object>> list= Jdbc_Template.JdbcTemp.queryForList("select * from province"); 结果: [{id=1, NAME=北京}, {id=2, NAME=上海}, {id=3, NAME=广州}, {id=4, NAME=陕西}] //map内 : key 对应的 字段 value 对应 值
查询指定列 List<T> queryForList(sql, T.class, …)
复制代码
1
2
3
4
5List<String> list= Jdbc_Template.JdbcTemp.queryForList("select NAME from province", String.class); 结果: [北京, 上海, 广州, 陕西]
查询数据条数 T queryForObject(sql , T.class , …)
复制代码
1
2
3
4
5
6
7
8
9
10
11//查询 String sql = "select count(*) from xinwen "; //上面?号 对应下面的参数 int num= Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class); System.out.println(num); //当然还可以有条件的 String sql="select count(*) from user where username=? and password=? "; int num = Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class,username,password);
查询 一条数据存映射到 对象里
T queryForObject(sql , new BeanPropertyRowMapper<>(T.class) , …)
复制代码
1
2
3
4
5
6
7封装好get set 进行映射 映射的属性 要和数据库 中的字段名一样 否则 无法映射成功 String sql="select * from user where username=?"; bean ben1=Jdbc_Template.JdbcTemp.queryForObject(sql,new BeanPropertyRowMapper<bean>(bean.class),"huanmin");
查询多条数据映射到对象里 并且保存在 List<对象>
List<T> query(sql, new BeanPropertyRowMapper<>(T.class) , …)
复制代码
1
2
3
4
5
6
7
8
9
10
11
12封装好get set 进行映射 映射的属性 要和数据库 中的字段名一样 否则 无法映射成功 //查询 String sql = "select * from xinwen where author=?"; BeanPropertyRowMapper Bean = new BeanPropertyRowMapper<>(Entity.class); //上面?号 对应下面的参数 List<Entity> list=Jdbc_Template.JdbcTemp.query(sql,Bean,"哪啊"); for (Entity en:list){ System.out.println(en.toString()); }
模糊查询
不能在?的前后添加 任何符号 所以 需要在最后 传参的时候 将%给他拼接进去
完整版的sql 语句:
select * from user where 1=1 and name like ? and address like ? and email like ?
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22Map<String, String[]> 是前端传递来的url参数 @Override public List<User> findUser(Map<String, String[]> a) { String sql="select * from user where 1=1"; StringBuilder stringBuilder=new StringBuilder(sql); List<Object> par=new ArrayList<>(); Set<String> keys=a.keySet(); for (String key:keys) { stringBuilder.append(" and "+key+" like ?"); String value=a.get(key)[0]; par.add("%"+value+"%"); } sql=stringBuilder.toString(); System.out.println(sql); return Jdbc_Template.JdbcTemp.query(sql,new BeanPropertyRowMapper<>(User.class),par.toArray()) ; } par.toArray()将集合转变成 数组 因为query这个方法最后是一个可变Object参数
分页查询
当前页数 3
每页多少显示条数据 4
select * from user where limit (3-1)*4,4
复制代码
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关键代码 //求出一共多少条 public static int count(){ String sql="select count(*) from day_1"; int num= Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class); return num; } @Override public List<Entity> select_fenye(int num) { //每页只显示4条 所以/4 然后如果多余的在另起一页 int ye_num=Math.ceil( (double) count()/4) //判断页码 和 传进来的页数 if (ye_num<num){ return null; } String sql="select * from day_1 LIMIT ?,4 "; //每页只显示4条数据 BeanPropertyRowMapper Bean= new BeanPropertyRowMapper<>(Entity.class); List<Entity> list= Jdbc_Template.JdbcTemp.query(sql,Bean,(num-1)*4); return list; }
兼容模糊和分页
也就是你模糊查询出来的数据太多了 利用分页给拆分下
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23private int mohu(String name ,String address,String email){ String sql="select count(*) from user where name like ? and address like ? and email like ?"; return Jdbc_Template.JdbcTemp.queryForObject(sql,Integer.class,"%"+name+"%","%"+address+"%","%"+email+"%"); } @Override public PageBean<User> Fenye(String name ,String address,String email,int currentPage) { PageBean<User> pageBean=new PageBean<>(); String sql="select * from user where name like ? and address like ? and email like ? LIMIT ?,?"; Object[] objects={"%"+name+"%","%"+address+"%","%"+email+"%",(currentPage-1)*pageBean.getRows(),pageBean.getRows()}; List<User> users=Jdbc_Template.JdbcTemp.query(sql,new BeanPropertyRowMapper<>(User.class),objects); pageBean.setCurrentPage(currentPage); pageBean.setList(users);//数据 int num=mohu( name,address,email); pageBean.setPageConunt(num);//总条数 pageBean.setTotalPage(num%pageBean.getRows()==0?num/pageBean.getRows():(num/pageBean.getRows())+1);//种页码 pageBean.setName(name); pageBean.setAddress(address); pageBean.setEmail(email); return pageBean; }
pageBean 类自己定义
Rows每页显示的条数 使用前就定义好
CurrentPage 当点击的页数
List 查询出来的 数据
PageConunt 数据总条数
TotalPage 分页的总页数
Name 保存模糊查询的name数据
Address保存模糊查询的address数据
Email保存模糊查询的Email数据
为什么要保存 模糊查询的数据
因为如果我点击下一页了 那么他怎么找到你要模糊查询的下一页数据 是不是还是要通过模糊查询的数据 来算出来 的要查询的第几页 具体怎么操作那么就看你自己了有很多办法 , 师傅领进门,代码看个人
事务的用法 参考JDBC (将名称换成Jdbc_Template)
存储过程
获取连接的方法上面有
无返回值的存储过程调用：
复制代码
1
2
3
4public void test(){ this.jdbcTemplate.execute("call testpro('p1','p2')"); }
有返回值的存储过程（非结果集）
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public void test() { String param2Value = (String) jdbcTemplate.execute( new CallableStatementCreator() { public CallableStatement createCallableStatement(Connection con) throws SQLException { String storedProc = "{call testpro(?,?)}";// 调用的sql CallableStatement cs = con.prepareCall(storedProc); cs.setString(1, "p1");// 设置输入参数的值 cs.registerOutParameter(2, Java.Sql.Types.VARCHAR);// 注册输出参数的类型 return cs; } }, new CallableStatementCallback() { public Object doInCallableStatement(CallableStatement cs) throws SQLException, DataAccessException { cs.execute(); return cs.getString(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
33public void test() { List resultList = (List) jdbcTemplate.execute( new CallableStatementCreator() { public CallableStatement createCallableStatement(Connection con) throws SQLException { String storedProc = "{call testpro(?,?)}";// 调用的sql CallableStatement cs = con.prepareCall(storedProc); cs.setString(1, "p1");// 设置输入参数的值 cs.registerOutParameter(2, OracleTypes.CURSOR);// 设置输出参数的类型 return cs; } }, new CallableStatementCallback() { public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException { List resultsMap = new ArrayList(); cs.execute(); ResultSet rs = (ResultSet) cs.getObject(2);// 获取游标一行的值 while (rs.next()) {// 转换每行的返回值到Map中 Map rowMap = new HashMap(); rowMap.put("id", rs.getString("id")); rowMap.put("name", rs.getString("name")); resultsMap.add(rowMap); } rs.close(); return resultsMap; } }); for (int i = 0; i < resultList.size(); i++) { Map rowMap = (Map) resultList.get(i); String id = rowMap.get("id").toString(); String name = rowMap.get("name").toString(); System.out.println("id=" + id + ";name=" + name); } }
最后
以上就是洁净枫叶最近收集整理的关于Java数据库连接大全-基础版Java数据库连接大全-基础版的全部内容，更多相关Java数据库连接大全-基础版Java数据库连接大全-基础版内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复