文章
文章用户文档快讯圈子网址导航

基于lucene的案例开发：数据库连接池

释放双眼，带上耳机，听听看~！

转载请注明出处： http://www.voidcn.com/article/p-eyavkxup-bkz.html
通过java程序去连接数据库时，使用的协议是TCP/IP协议，TCP/IP协议需要进行3次握手。如果每一次数据库操作都需要创建一个新的连接，都要进行3次握手，这是十分浪费资源的，程序的效率也不是很高。为了解决这个问题，我们想可不可以自己维护一些数据库连接，需要数据库操作的时候，直接使用这其中的一个连接，用完了，在还给它，这样的话就不需要每次数据库操作都创建一个新的连接了。这种思维模式就是今天的博客主题数据库连接池。

基本原理

      连接池技术的核心思想是：连接复用，通过建立一个数据库连接池以及一套连接使用、分配、管理策略，使得该连接池中的连接可以得到高效、安全的复用，避免了数据库连接频繁建立、关闭的开销。另外，由于对JDBC中的原始连接进行了封装，从而方便了数据库应用对于连接的使用（特别是对于事务处理），提高了开发效率，也正是因为这个封装层的存在，隔离了应用的本身的处理逻辑和具体数据库访问逻辑，使应用本身的复用成为可能。连接池主要由三部分组成（如下图所示）：连接池的建立、连接池中连接的使用管理、连接池的关闭。

基于lucene的案例开发：数据库连接池

      
连接池实现
这里的介绍的连接池是proxool，这里对其做了进一步的封装，使数据库操作更加简单。
DBPool
DBPool类用于指定数据库连接池的配置文件，源程序如下：



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
1 /**  

2 *@Description:  数据库连接池配置   

3 */ 

4package com.lulei.db.manager;  

5

6import org.apache.log4j.Logger;

7

8import com.lulei.util.ClassUtil;

9  

10public class DBPool {

11  private static DBPool dbPool = null;

12  private String poolPath;

13  private static Logger log = Logger.getLogger(DBPool.class);

14  private static String path = ClassUtil.getClassRootPath(DBPool.class);

15  

16  public static DBPool getDBPool(){

17      if (dbPool == null){

18          synchronized(DBPool.class){

19              if (dbPool == null){

20                  dbPool = new DBPool();

21              }

22          }

23      }

24      return dbPool;

25  }

26  

27  private DBPool(){

28      

29  }

30  

31  /**

32   * @param poolPath

33   * @Author: lulei  

34   * @Description: 设置数据库连接池配置文件路径

35   */

36  public void setPoolPath(String poolPath){

37      this.poolPath = poolPath;

38  }

39  

40  /**

41   * @return

42   * @Author: lulei  

43   * @Description: 返回数据库连接池配置文件路径

44   */

45  protected String getPoolPath(){

46      //如果没有指定配置文件，则使用默认配置文件

47      if (poolPath == null){

48          poolPath = path + "proxool.xml";

49          log.info("Database's poolpath is null, use default path:" + poolPath);

50      }

51      return poolPath;

52  }

53}

54

55





1
2
1         在配置文件中，参数介绍如下：   

2

fatal-sql-exception: 它是一个逗号分割的信息片段.当一个SQL异常发生时,他的异常信息将与这个信息片段进行比较.如果在片段中存在,那么这个异常将被认为是个致命错误(Fatal SQL Exception ).这种情况下,数据库连接将要被放弃.无论发生什么,这个异常将会被重掷以提供给消费者.用户最好自己配置一个不同的异常来抛出.
fatal-sql-exception-wrapper-class:正如上面所说,你最好配置一个不同的异常来重掷.利用这个属性,用户可以包装SQLException,使他变成另外一个异常.这个异常或者继承SQLException或者继承字RuntimeException.proxool自带了2个实现:'org.logicalcobwebs.proxool.FatalSQLException' 和'org.logicalcobwebs.proxool.FatalRuntimeException' .后者更合适.
house-keeping-sleep-time: house keeper 保留线程处于睡眠状态的最长时间,house keeper 的职责就是检查各个连接的状态,并判断是否需要销毁或者创建.
house-keeping-test-sql:  如果发现了空闲的数据库连接.house keeper 将会用这个语句来测试.这个语句最好非常快的被执行.如果没有定义,测试过程将会被忽略。
injectable-connection-interface: 允许proxool实现被代理的connection对象的方法.
injectable-statement-interface: 允许proxool实现被代理的Statement 对象方法.
injectable-prepared-statement-interface: 允许proxool实现被代理的PreparedStatement 对象方法.
injectable-callable-statement-interface: 允许proxool实现被代理的CallableStatement 对象方法.
jmx: 略
jmx-agent-id: 略
jndi-name: 数据源的名称
maximum-active-time: 如果housekeeper 检测到某个线程的活动时间大于这个数值.它将会杀掉这个线程.所以确认一下你的服务器的带宽.然后定一个合适的值.默认是5分钟.
maximum-connection-count: 最大的数据库连接数.
maximum-connection-lifetime: 一个线程的最大寿命.
minimum-connection-count: 最小的数据库连接数
overload-without-refusal-lifetime: 略
prototype-count: 连接池中可用的连接数量.如果当前的连接池中的连接少于这个数值.新的连接将被建立(假设没有超过最大可用数).例如.我们有3个活动连接2个可用连接,而我们的prototype-count是4,那么数据库连接池将试图建立另外2个连接.这和 minimum-connection-count不同. minimum-connection-count把活动的连接也计算在内.prototype-count 是spare connections 的数量.
recently-started-threshold:  略
simultaneous-build-throttle:  略
statistics:  连接池使用状况统计。 参数“10s,1m,1d”
statistics-log-level:  日志统计跟踪类型。 参数“ERROR”或 “INFO”
test-before-use: 略
test-after-use: 略
trace: 如果为true,那么每个被执行的SQL语句将会在执行期被log记录(DEBUG LEVEL).你也可以注册一个ConnectionListener (参看ProxoolFacade)得到这些信息.
verbose: 详细信息设置。 参数 bool 值
在本例中数据库连接池配置文件如下：



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
1<?xml version="1.0" encoding="UTF-8"?> 

2<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">  

3<proxool-config>

4<proxool> 

5    <alias>novelSelect</alias> 

6       <driver-url><![CDATA[jdbc:mysql://172.20.37.73:3306/novel?characterEncoding=utf-8]]></driver-url> 

7    <driver-class>com.mysql.jdbc.Driver</driver-class> 

8    <driver-properties> 

9      <property name="user" value="root"/> 

10      <property name="password" value="root"/> 

11    </driver-properties> 

12     <house-keeping-sleep-time>900000</house-keeping-sleep-time>

13   <maximum-active-time>500000</maximum-active-time>

14   <maximum-connection-count>40</maximum-connection-count>

15   <minimum-connection-count>4</minimum-connection-count> 

16    <house-keeping-test-sql>select 1</house-keeping-test-sql>

17    <prop key="hibernate.connection.release_mode">after_transaction</prop>  

18</proxool> 

19<proxool> 

20    <alias>novelEdit</alias> 

21      <driver-url><![CDATA[jdbc:mysql://172.20.37.73:3306/novel?characterEncoding=utf-8]]></driver-url> 

22    <driver-class>com.mysql.jdbc.Driver</driver-class> 

23    <driver-properties> 

24      <property name="user" value="root"/> 

25      <property name="password" value="root"/> 

26    </driver-properties> 

27     <house-keeping-sleep-time>900000</house-keeping-sleep-time>

28   <maximum-active-time>500000</maximum-active-time>

29   <maximum-connection-count>10</maximum-connection-count>

30   <minimum-connection-count>4</minimum-connection-count> 

31    <house-keeping-test-sql>select 1</house-keeping-test-sql>

32    <prop key="hibernate.connection.release_mode">after_transaction</prop>  

33</proxool> 

34</proxool-config>

35

36





1
2
1   **DBManager**   

2

      DBManager在系统中是单例模式，在初始化只需要简单的两句代码：



1
2
3
1           JAXPConfigurator.configure(DBPool.getDBPool().getPoolPath(), false);

2           Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");

3





1
2
1         获取数据库连接也只是简单的一句代码：   

2





1
2
1return DriverManager.getConnection(poolName);

2





1
2
1         DBManager源代码如下：   

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
1 /**  

2 *@Description: 数据库连接池管理    

3 */ 

4package com.lulei.db.manager;  

5

6import java.sql.Connection;

7import java.sql.DriverManager;

8import java.sql.SQLException;

9

10import org.logicalcobwebs.proxool.configuration.JAXPConfigurator;

11

12public class DBManager {

13

14  private static DBManager dBManager = null;

15  

16  private DBManager(){

17      try {

18          JAXPConfigurator.configure(DBPool.getDBPool().getPoolPath(), false);

19          Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");

20      } catch (Exception  e){

21          e.printStackTrace();

22      }

23  }

24  

25  /**

26   * @return DBManager

27   * @Author: lulei  

28   * @Description: 获取数据库连接池管理对象

29   */

30  protected static DBManager getDBManager(){

31      if (dBManager == null){

32          synchronized(DBManager.class){

33              if (dBManager == null){

34                  dBManager = new DBManager();

35              }

36          }

37      }

38      return dBManager;

39  }

40  

41  /**

42   * @param poolName

43   * @return Connection

44   * @throws SQLException

45   * @Author: lulei  

46   * @Description: 获取数据库链接

47   */

48  protected Connection getConnection(String poolName) throws SQLException{

49      return DriverManager.getConnection(poolName);

50  }

51}

52

53





1
2
1   **DBOperation**   

2

      为了简化数据库的操作，对数据库操作进行再一次封装成DBOperation类。在setPres方法中，这里只做了几种简单的数据类型，关于其他复杂的数据类型可以根据项目需要添加。源代码如下：



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
1 /**  

2 *@Description: 数据库操作    

3 */ 

4package com.lulei.db.manager;  

5

6import java.sql.Connection;

7import java.sql.PreparedStatement;

8import java.sql.ResultSet;

9import java.sql.SQLException;

10import java.sql.Statement;

11import java.util.HashMap;

12

13import org.apache.log4j.Logger;

14  

15public class DBOperation {

16

17  private static Logger log = Logger.getLogger(DBOperation.class);

18  private Connection conn = null;

19  private String poolName;

20  

21  /**

22  * @param poolName

23   */

24  public DBOperation(String poolName){

25      this.poolName = poolName;

26  }

27  

28  /**

29   * @throws SQLException

30   * @Author: lulei  

31   * @Description: 获取Connection

32   */

33  private void open() throws SQLException{

34      this.conn = DBManager.getDBManager().getConnection(poolName);

35  }

36  

37  /**

38   * @Author: lulei  

39   * @Description: 关闭Connection

40   */

41  public void close() {

42      try {

43          if (this.conn != null) {

44              this.conn.close();

45          }

46      } catch (SQLException e) {

47          // TODO Auto-generated catch block  

48          e.printStackTrace();

49      }

50  }

51  

52  /**

53   * @param sql组装的sql字符串

54   * @param params传入的参数

55   * @throws SQLException

56   * @throws ClassNotFoundException

57   * @Author: lulei  

58   * @Description: 组装PreparedStatement

59   */

60  private PreparedStatement setPres(String sql, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

61      if (null != params) {

62          if (0 < params.size()){

63              PreparedStatement pres = this.conn.prepareStatement(sql);

64              for (int i = 1; i <= params.size(); i++){

65                  if (params.get(i).getClass() == Class.forName("java.lang.String")){

66                      pres.setString(i, params.get(i).toString());

67                  } else if (params.get(i).getClass() == Class.forName("java.lang.Integer")){

68                      pres.setInt(i, (Integer) params.get(i));

69                  } else if (params.get(i).getClass() == Class.forName("java.lang.Boolean")){

70                      pres.setBoolean(i, (Boolean) params.get(i));

71                  } else if (params.get(i).getClass() == Class.forName("java.lang.Float")){

72                      pres.setFloat(i, (Float) params.get(i));

73                  } else if (params.get(i).getClass() == Class.forName("java.lang.Double")){

74                      pres.setDouble(i, (Double) params.get(i));

75                  } else if (params.get(i).getClass() == Class.forName("java.lang.Long")){

76                      pres.setLong(i, (Long) params.get(i));

77                  } else if (params.get(i).getClass() == Class.forName("java.sql.Date")){

78                      pres.setDate(i, java.sql.Date.valueOf(params.get(i).toString()));

79                  } else {

80                      log.info("not found class : " + params.get(i).getClass().toString());

81                      return null;

82                  }

83              }

84              return pres;

85          }

86      }

87      return null;

88  }

89  

90  /**

91   * @param sql

92   * @return int

93   * @throws SQLException

94   * @Author: lulei  

95   * @Description: executeUpdate

96   */

97  protected int executeUpdate(String sql) throws SQLException{

98      this.open();

99      Statement state = this.conn.createStatement();

100     int re = state.executeUpdate(sql);

101     return re;

102 }

103 

104 /**

105  * executeUpdate

106  * @param sql

107  * @param params

108  * @return int

109  * @throws SQLException

110  * @throws ClassNotFoundException

111  * @Author: lulei  

112  * @Description:

113  */

114 protected int executeUpdate(String sql, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

115     this.open();

116     PreparedStatement pres = setPres(sql, params);

117     int re = 0;

118     if (null != pres) {

119         re = pres.executeUpdate();

120     }

121     return re;

122 }

123 

124 /**

125  * getGeneratedKeys

126  * @param sql

127  * @return ResultSet

128  * @throws SQLException

129  * @Author: lulei  

130  * @Description:

131  */

132 protected ResultSet getGeneratedKeys(String sql) throws SQLException{

133     this.open();

134     Statement state = this.conn.createStatement();

135     state.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);

136     ResultSet re = state.getGeneratedKeys();

137     return re;

138 }

139 

140 /**

141  * getGeneratedKeys

142  * @param sql

143  * @param params

144  * @return ResultSet

145  * @throws SQLException

146  * @throws ClassNotFoundException

147  * @Author: lulei  

148  * @Description:

149  */

150 protected ResultSet getGeneratedKeys(String sql, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

151     this.open();

152     PreparedStatement pres = setPres(sql, params);

153     if (null != pres) {

154         pres.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);

155         ResultSet re = pres.getGeneratedKeys();

156         return re;

157     }

158     return null;

159 }

160 

161 /**

162  * @param sql

163  * @return ResultSet

164  * @throws SQLException

165  * @Author: lulei  

166  * @Description: executeQuery

167  */

168 protected ResultSet executeQuery(String sql) throws SQLException{

169     this.open();

170     Statement state = this.conn.createStatement();

171     ResultSet re = state.executeQuery(sql);

172     return re;

173 }

174 

175 /**

176  * @param sql

177  * @param params

178  * @return ResultSet

179  * @throws SQLException

180  * @throws ClassNotFoundException

181  * @Author: lulei  

182  * @Description: executeQuery

183  */

184 protected ResultSet executeQuery(String sql, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

185     this.open();

186     PreparedStatement pres = setPres(sql, params);

187     if (null != pres) {

188         ResultSet re = pres.executeQuery();

189         return re;

190     }

191     return null;

192 }

193}

194

195





1
2
1   **DBServer**   

2

      DBServer对数据库的增删该查操作进行进一步的细化，源代码如下：



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
1 /**  

2 *@Description:  增删改查四个数据库操作接口

3 */ 

4package com.lulei.db.manager;  

5

6import java.sql.ResultSet;

7import java.sql.SQLException;

8import java.util.HashMap;

9

10public class DBServer {

11  

12  private DBOperation dBOperation;

13  

14  /**

15  * @param poolName

16  * @Description: 在使用该类之前，请保证函数DBPool.getDBPool().setPoolPath()已经运行

17   */

18  public DBServer(String poolName){

19      dBOperation = new DBOperation(poolName);

20  }

21  

22  /**

23   * @Author: lulei  

24   * @Description: 释放链接，在执行完数据库操作，必须执行此命令

25   */

26  public void close(){

27      dBOperation.close();

28  }

29  

30  /**

31   * @param table

32   * @param columns

33   * @param params

34   * @return int

35   * @throws SQLException

36   * @throws ClassNotFoundException

37   * @Author: lulei  

38   * @Description: insert 执行完此命令后，执行close()操作

39   */

40  public int insert(String table, String columns, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

41      String sql = insertSql(columns, table);

42      return dBOperation.executeUpdate(sql, params);

43  }

44  

45  /**

46   * @param sql

47   * @return int

48   * @throws SQLException

49   * @Author: lulei  

50   * @Description: insert 执行完此命令后，执行close()操作

51   */

52  public int insert(String sql) throws SQLException {

53      return dBOperation.executeUpdate(sql);

54  }

55  

56  /**

57   * @param table

58   * @param columns

59   * @param params

60   * @return ResultSet

61   * @throws SQLException

62   * @throws ClassNotFoundException

63   * @Author: lulei  

64   * @Description: insertGetGeneratedKeys 执行完此命令后，执行close()操作

65   */

66  public ResultSet insertGetGeneratedKeys(String table, String columns, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

67      String sql = insertSql(columns, table);

68      return dBOperation.getGeneratedKeys(sql, params);

69  }

70  

71  /**

72   * @param sql

73   * @return ResultSet

74   * @throws SQLException

75   * @Author: lulei  

76   * @Description: insertGetGeneratedKeys 执行完此命令后，执行close()操作

77   */

78  public ResultSet insertGetGeneratedKeys(String sql) throws SQLException{

79      return dBOperation.getGeneratedKeys(sql);

80  }

81

82  /**

83   * @param table

84   * @param condition

85   * @return int

86   * @throws SQLException

87   * @Author: lulei  

88   * @Description: delete 执行完此命令后，执行close()操作

89   */

90  public int delete(String table, String condition) throws SQLException{

91      if(null == table){

92          return 0;

93      }

94      String sql = "delete from " + table + " " + condition;

95      return dBOperation.executeUpdate(sql);

96  }

97  

98  /**

99   * @param sql

100  * @return int

101  * @throws SQLException

102  * @Author: lulei  

103  * @Description: delete 执行完此命令后，执行close()操作

104  */

105 public int delete(String sql) throws SQLException{

106     return dBOperation.executeUpdate(sql);

107 }

108 

109 /**

110  * @param columns

111  * @param table

112  * @param condition

113  * @return ResultSet

114  * @throws SQLException

115  * @Author: lulei  

116  * @Description: select 执行完此命令后，执行close()操作

117  */

118 public ResultSet select(String columns, String table, String condition) throws SQLException {

119     String sql = "select " + columns + " from " + table + " " + condition;

120     return dBOperation.executeQuery(sql);

121 }

122 

123 /**

124  * @param sql

125  * @return ResultSet

126  * @throws SQLException

127  * @Author: lulei  

128  * @Description: select 执行完此命令后，执行close()操作

129  */

130 public ResultSet select(String sql) throws SQLException{

131     return dBOperation.executeQuery(sql);

132 }

133 

134 /**

135  * @param table

136  * @param columns

137  * @param condition

138  * @param params

139  * @return int

140  * @throws SQLException

141  * @throws ClassNotFoundException

142  * @Author: lulei  

143  * @Description: update 执行完此命令后，执行close()操作

144  */

145 public int update(String table, String columns, String condition, HashMap<Integer, Object> params) throws SQLException, ClassNotFoundException{

146     String sql = updateString(table, columns, condition);

147     return dBOperation.executeUpdate(sql, params);

148 }

149 

150 /**

151  * @param sql

152  * @return int

153  * @throws SQLException

154  * @Author: lulei  

155  * @Description:  update 执行完此命令后，执行close()操作

156  */

157 public int update(String sql) throws SQLException{

158     return dBOperation.executeUpdate(sql);

159 }

160 

161 /**

162  * @param table

163  * @param columns

164  * @param condition

165  * @return String

166  * @Author: lulei  

167  * @Description: 组装updateString

168  */

169 private String updateString(String table, String columns, String condition) {

170     if (null == columns || null == table) {

171         return "";

172     }

173     String[] column = columns.split(",");

174     StringBuilder stringBuilder = new StringBuilder("update ");

175     stringBuilder.append(table);

176     stringBuilder.append(" set ");

177     stringBuilder.append(column[0]);

178     stringBuilder.append("=?");

179     for (int i = 1; i < column.length; i++){

180         stringBuilder.append(", ");

181         stringBuilder.append(column[i]);

182         stringBuilder.append("=?");

183     }

184     stringBuilder.append(" ");

185     stringBuilder.append(condition);

186     return stringBuilder.toString();

187 }

188 

189 /**

190  * @param columns

191  * @param table

192  * @return String

193  * @Author: lulei  

194  * @Description: 组装insertSql

195  */

196 private String insertSql(String columns, String table){

197     if (null == columns || null == table) {

198         return "";

199     }

200     int colNum = columns.split(",").length;

201     StringBuilder stringBuilder = new StringBuilder("insert into ");

202     stringBuilder.append(table);

203     stringBuilder.append(" (");

204     stringBuilder.append(columns);

205     stringBuilder.append(") values (?");

206     for (int i = 1; i < colNum; i++) {

207         stringBuilder.append(",?");

208     }

209     stringBuilder.append(")");

210     return stringBuilder.toString();

211 }

212}

213

214





1
2
1         下面是的使用事例是其他项目中的一个例子，这里可以简单的看下，代码如下：   

2





1
2
3
4
5
6
7
8
9
10
11
12
13
14
1   public boolean support(String docNo){

2       DBServer dbServer = new DBServer(dbPoolName);

3       String editTime = System.currentTimeMillis() + "";

4       String sql = "update " + SolutionTable.tableName + " set " + SolutionTable.support + "=" + SolutionTable.support + "+1, " + SolutionTable.editTime + "='"+ editTime+"' where " +SolutionTable.docNo + "='" + docNo + "'";

5       try {

6           return dbServer.update(sql) > 0;

7       } catch (SQLException e) {

8           e.printStackTrace();

9       } finally {

10          dbServer.close();

11      }

12      return false;

13  }

14





1
2
1   ps:最近发现其他网站可能会对博客转载，上面并没有源链接，如想查看更多关于 基于lucene的案例开发 请 点击这里。或访问网址http://blog.csdn.net/xiaojimanman/article/category/2841877   

2

Related posts:

  1. 带你玩转kubernetes-k8s（第49篇：深入分析k8s网络原理-[直接路由，Calico部署]）
  2. ElasticSearch大数据分布式弹性搜索引擎使用—从0到1
  3. MYSQL优化和备份
  4. MySQL性能调优my.cnf详解（mysql5.6版本）

给TA打赏
共{{data.count}}人
人已打赏
[db:标签]mysql命令安全数据服务器系统网址隔离
安全运维

OpenSSH-8.7p1离线升级修复安全漏洞

2021-10-23 10:13:25

安全运维

设计模式的设计原则

2021-12-12 17:36:11

猜你喜欢

MYSQL优化和备份

026
❯

解锁会员权限

开通会员

解锁海量优质VIP资源

立刻开通
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索

  • 扫码打开当前页

返回顶部