一、首先配置JdbcTemplate；

要使用Jdbctemplate 物件來完成jdbc 操作。通常情況下，有三種種方式得到JdbcTemplate 物件。 
      第一種方式：我們可以在自己定義的DAO 實現類中注入一個DataSource 引用來完 成JdbcTemplate 的例項化。也就是它是從外部“注入” DataSource 到DAO 中，然後 自己例項化JdbcTemplate，然後將DataSource 設定到JdbcTemplate 物件中。 
      第二種方式： 在 Spring 的 IoC 容器中配置一個 JdbcTemplate的 bean，將 DataSource 注入進來，然後再把JdbcTemplate 注入到自定義DAO 中。 
     第三種方式

: Spring 提供了 org.springframework.jdbc.core.support.JdbcDaoSupport 類 ， 這 個 類 中 定 義 了 JdbcTemplate 屬性，也定義了DataSource 屬性，當設定DataSource 屬性的時候，會創 建jdbcTemplate 的例項，所以我們自己編寫的DAO 只需要繼承JdbcDaoSupport 類， 然後注入DataSource 即可。提倡採用第三種方法。雖然下面的用法中採用了前兩種方法

  配置方法有3種：

     1、

Java程式碼  

1.      public class UserServiceImpl implements

 UserService {  

2.        

3.          private JdbcTemplate jdbcTemplate;  

4.            

5.          public JdbcTemplate getJdbcTemplate() {  

6.              return jdbcTemplate;  

7.          }  

8.        

9.                      //注入方法1     

10.      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  

11.          this.jdbcTemplate = jdbcTemplate;  

12.      }  

13.    

14.                 //其它方法這裡省略……  

15.  }  

 spring配置檔案為：

Xml程式碼  

1.      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  

2.              <property name = "dataSource" ref="dataSource">  

3.      </bean>  

4.      <bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">  

5.           <property name="jdbcTemplate" ref="jdbcTemplate"/>  

6.      </bean>  

   方法2、

Java程式碼  

1.      public class UserServiceImpl implements UserService {  

2.        

3.              private JdbcTemplate jdbcTemplate;  

4.                

5.              //注入方法2  

6.              public void setDataSource(DataSource dataSource) {  

7.                         this.jdbcTemplate = new JdbcTemplate(dataSource);  

8.              }  

9.             

10.         //其它方法省略……  

11.  }  

 spring配置檔案為：

Xml程式碼  

1.      <bean id="userService" class="com.hxzy.account.jdbcTemplate.UserServiceImpl">  

2.             <property name="dataSource" ref="dataSource"/>  

3.      </bean>  

方法3：繼承JdbcDaoSupport，其內部有個JdbcTemplate ，需要注入DataSource 屬性來例項化。

Java程式碼  

1.      public class UserDaoImpl extends JdbcDaoSupport implements UserDao {  

2.        

3.          @Override  

4.          public void save(User user) {  

5.              String sql = null;  

6.              this.getJdbcTemplate().update(sql);  

7.          }  

8.              //其它方法省略……  

9.      }  

spring配置檔案：

Xml程式碼  

1.      <bean id="userDao" class="com.hxzy.account.jdbcTemplate.UserDaoImpl">  

2.                 <property name="dataSource" ref="dataSource"/>  

3.      </bean>  

二、常用方法使用

【注意：】jdbcTemplate 中的sql均是用“?”做佔位符的

domain User：

Java程式碼  

1.      public class User {  

2.          private int id;  

3.          private String username;  

4.          private String password;  

5.          private String sex;  

6.                    

7.                     //setter和getter方法省略……  

8.      }  

UserServiceImpl ：

如果採用第三種方式，則下面的用法中將方法中的 jdbcTemplate 換成 this.getJdbcTemplate()即可。

Java程式碼  

1.           /**   

2.           * 建立表 

3.           */   

4.          public void create(String tableName){ //tb_test1  

5.              jdbcTemplate.execute("create table "+tableName +" (id integer,user_name varchar2(40),password varchar2(40))");  

6.          }  

7.            

8.          //jdbcTemplate.update適合於insert 、update和delete操作；  

9.          /**   

10.       * 第一個引數為執行sql   

11.       * 第二個引數為引數資料 

12.       */   

13.      public void save3(User user) {  

14.          Assert.isNull(user, "user is not null");  

15.          jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   

16.                  new Object[]{user.getUsername(),user.getPassword()});  

17.      }  

18.        

19.      /**   

20.       * 第一個引數為執行sql   

21.       * 第二個引數為引數資料 

22.       * 第三個引數為引數型別 

23.       */   

24.      @Override  

25.      public void save(User user) {  

26.          Assert.isNull(user, "user is not null");  

27.          jdbcTemplate.update(  

28.                  "insert into tb_test1(name,password) values(?,?)",   

29.                  new Object[]{user.getUsername(),user.getPassword()},   

30.                  new int[]{java.sql.Types.VARCHAR,java.sql.Types.VARCHAR}  

31.                  );  

32.      }  

33.    

34.      //避免sql注入  

35.      public void save2(final User user) {  

36.          Assert.isNull(user, "user is not null");  

37.            

38.          jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   

39.                  new PreparedStatementSetter(){  

40.                

41.                      @Override  

42.                      public void setValues(PreparedStatement ps) throws SQLException {  

43.                          ps.setString(1, user.getUsername());  

44.                          ps.setString(2, user.getPassword());  

45.                      }  

46.          });  

47.            

48.      }  

49.        

50.      public void save4(User user) {  

51.          Assert.isNull(user, "user is not null");  

52.          jdbcTemplate.update("insert into tb_test1(name,password) values(?,?)",   

53.                               new Object[]{user.getUsername(),user.getPassword()});  

54.      }  

55.        

56.      //返回插入的主鍵  

57.      public List save5(final User user) {  

58.            

59.          KeyHolder keyHolder = new GeneratedKeyHolder();  

60.    

61.          jdbcTemplate.update(new PreparedStatementCreator() {  

62.                        

63.                                  @Override  

64.                                  public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {  

65.                                      PreparedStatement ps = connection.prepareStatement("insert into tb_test1(name,password) values(?,?)", new String[] {"id"});  

66.                                      ps.setString(1, user.getUsername());  

67.                                      ps.setString(2, user.getPassword());  

68.                                      return ps;  

69.                                  }  

70.                              },  

71.                  keyHolder);  

72.            

73.          return keyHolder.getKeyList();  

74.      }  

75.        

76.      @Override  

77.      public void update(final User user) {  

78.          jdbcTemplate.update(  

79.                  "update tb_test1 set name=？,password=？ where id = ?",   

80.                  new PreparedStatementSetter(){  

81.                      @Override  

82.                      public void setValues(PreparedStatement ps) throws SQLException {  

83.                          ps.setString(1, user.getUsername());  

84.                          ps.setString(2, user.getPassword());  

85.                          ps.setInt(3, user.getId());  

86.                      }  

87.                  }  

88.          );  

89.      }  

90.    

91.      @Override  

92.      public void delete(User user) {  

93.          Assert.isNull(user, "user is not null");  

94.          jdbcTemplate.update(  

95.                  "delete from tb_test1 where id = ?",   

96.                  new Object[]{user.getId()},   

97.                  new int[]{java.sql.Types.INTEGER});  

98.      }  

99.    

100.       @Deprecated //因為沒有查詢條件，所以用處不大  

101.       public int queryForInt1(){  

102.           return jdbcTemplate.queryForInt("select count(0) from tb_test1");  

103.       }  

104.         

105.       public int queryForInt2(User user){  

106.           return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  

107.                   new Object[]{user.getUsername()});  

108.       }  

109.         

110.       //最全的引數3個  

111.       public int queryForInt3(User user){  

112.           return jdbcTemplate.queryForInt("select count(0) from tb_test1 where username = ?" ,  

113.                   new Object[]{user.getUsername()},  

114.                   new int[]{java.sql.Types.VARCHAR});  

115.       }  

116.         

117.       //可以返回是一個基本型別的值  

118.       @Deprecated  //因為沒有查詢條件，所以用處不大  

119.       public String queryForObject1(User user) {  

120.           return (String) jdbcTemplate.queryForObject("select username from tb_test1 where id = 100",  

121.                                                       String.class);  

122.       }  

123.         

124.       //可以返回值是一個物件  

125.       @Deprecated //因為沒有查詢條件，所以用處不大  

126.       public User queryForObject2(User user) {  

127.           return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100", User.class); //class是結果資料的java型別  

128.       }  

129.         

130.       @Deprecated //因為沒有查詢條件，所以用處不大  

131.       public User queryForObject3(User user) {  

132.           return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100",   

133.                       new RowMapper(){  

134.         

135.                           @Override  

136.                           public Object mapRow(ResultSet rs, int rowNum)throws SQLException {  

137.                               User user  = new User();  

138.                               user.setId(rs.getInt("id"));  

139.                               user.setUsername(rs.getString("username"));  

140.                               user.setPassword(rs.getString("password"));  

141.                               return user;  

142.                           }  

143.                       }  

144.           );   

145.       }  

146.         

147.       public User queryForObject4(User user) {  

148.           return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",   

149.                                                       new Object[]{user.getId()},  

150.                                                       User.class); //class是結果資料的java型別實際上這裡是做反射，將查詢的結果和User進行對應複製  

151.       }  

152.         

153.       public User queryForObject5(User user) {  

154.           return (User) jdbcTemplate.queryForObject(  

155.                   "select * from tb_test1 where id = ?",   

156.                   new Object[]{user.getId()},  

157.                   new RowMapper(){  

158.     

159.                       @Override  

160.                       public Object mapRow(ResultSet rs,int rowNum)throws SQLException {  

161.                           User user  = new User();  

162.                           user.setId(rs.getInt("id"));  

163.                           user.setUsername(rs.getString("username"));  

164.                           user.setPassword(rs.getString("password"));  

165.                           return user;  

166.                       }  

167.                 

168.           }); //class是結果資料的java型別  

169.       }  

170.         

171.       @Override  

172.       public User queryForObject(User user) {  

173.           //方法有返回值  

174.           return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = ?",  

175.                   new Object[]{user.getId()},  

176.                   new int[]{java.sql.Types.INTEGER},   

177.                   new RowMapper() {  

178.                 

179.                       @Override  

180.                       public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  

181.                           User user  = new User();  

182.                           user.setId(rs.getInt("id"));  

183.                           user.setUsername(rs.getString("username"));  

184.                           user.setPassword(rs.getString("password"));  

185.                           return user;  

186.                       }  

187.                   }  

188.           );  

189.       }  

190.     

191.       @SuppressWarnings("unchecked")  

192.       public List<User> queryForList1(User user) {  

193.           return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",   

194.                               new Object[]{user.getUsername()},  

195.                               User.class);  

196.       }  

197.     

198.       @SuppressWarnings("unchecked")  

199.       public List<String> queryForList2(User user) {  

200.           return (List<String>) jdbcTemplate.queryForList("select username from tb_test1 where sex = ?",   

201.                               new Object[]{user.getSex()},  

202.                               String.class);  

203.       }  

204.         

205.       @SuppressWarnings("unchecked")  

206.       //最全的引數查詢  

207.       public List<User> queryForList3(User user) {  

208.           return (List<User>) jdbcTemplate.queryForList("select * from tb_test1 where username = ?",  

209.                               new Object[]{user.getUsername()},  

210.                               new int[]{java.sql.Types.VARCHAR},  

211.                               User.class);  

212.       }  

213.     

214.       //通過RowCallbackHandler對Select語句得到的每行記錄進行解析，併為其建立一個User資料物件。實現了手動的OR對映。  

215.       public User queryUserById4(String id){  

216.           final User user  = new User();  

217.             

218.           //該方法返回值為void  

219.           this.jdbcTemplate.query("select * from tb_test1 where id = ?",   

220.                   new Object[] { id },   

221.                   new RowCallbackHandler() {     

222.                 

223.                       @Override    

224.                       public void processRow(ResultSet rs) throws SQLException {     

225.                           User user  = new User();  

226.               user.setId(rs.getInt("id"));  

227.               user.setUsername(rs.getString("username"));  

228.               user.setPassword(rs.getString("password"));    

229.                       }     

230.           });   

231.             

232.           return user;     

233.       }  

234.         

235.       @SuppressWarnings("unchecked")  

236.       @Override  

237.       public List<User> list(User user) {  

238.           return jdbcTemplate.query("select * from tb_test1 where username like '%?%'",   

239.                   new Object[]{user.getUsername()},   

240.                   new int[]{java.sql.Types.VARCHAR},   

241.                   new RowMapper(){  

242.                 

243.                       @Override  

244.                       public Object mapRow(ResultSet rs, int rowNum) throws SQLException {  

245.                           User user  = new User();  

246.                           user.setId(rs.getInt("id"));  

247.                           user.setUsername(rs.getString("username"));  

248.                           user.setPassword(rs.getString("password"));  

249.                           return user;  

250.                       }  

251.           });  

252.       }  

253.     

254.       //批量操作適合於增、刪、改操作  

255.       public int[] batchUpdate(final List users) {  

256.             

257.           int[] updateCounts = jdbcTemplate.batchUpdate(  

258.                   "update tb_test1 set username = ?, password = ? where id = ?",  

259.                   new BatchPreparedStatementSetter() {  

260.                         

261.                           @Override  

262.                           public void setValues(PreparedStatement ps, int i) throws SQLException {  

263.                               ps.setString(1, ((User)users.get(i)).getUsername());  

264.                               ps.setString(2, ((User)users.get(i)).getPassword());  

265.                               ps.setLong(3, ((User)users.get(i)).getId());  

266.                           }  

267.                             

268.                           @Override  

269.                           public int getBatchSize() {  

270.                               return users.size();  

271.                           }  

272.                   }   

273.           );  

274.             

275.           return updateCounts;  

276.       }  

277.         

278.       //呼叫儲存過程  

279.       public void callProcedure(int id){  

280.           this.jdbcTemplate.update("call SUPPORT.REFRESH_USERS_SUMMARY(?)", new Object[]{Long.valueOf(id)});  

281.   }  

其中，batchUpdate適合於批量增、刪、改操作；

        update(…)：使用於增、刪、改操作；

        execute（）：執行一個獨立的sql語句，包括ddl語句；

         queryForInt：查詢出一個整數值

queryForInt, queryForMap,queryForObject返回0行會拋異常的

Spring 中的 RowMapper

2012年11月17日 ⁄ 綜合 ⁄ 共 724字 ⁄ 字號 小 中大⁄ 評論關閉

Sping中的RowMapper可以將資料中的每一行資料封裝成使用者定義的類.

我們在資料庫查詢中，如果返回的型別是使用者自定義的型別(其實我們在資料庫查詢中大部分返回的都是自定義的類)則需要包裝，如果是Java自定義的型別，如：String則不需要.

如果sping與hibernate 相結合了,基本上是用不到,大多數都是在spring單獨使用時用到.

可以通過建立內部類實現RowMapper介面,RowMapper中有一個mapRow方法,所以實現RowMapper介面一定要實現mapRow方法,而對自定義類的包裝就在mapRow方法中實現.

這裡只是一個簡單的例子:

public class TestDao { private JdbcTemplate jt; public void setJt(JdbcTemplate jt) {    this.jt = jt; } public List<TNpc> getAll(){     String sql = "select * from t_npc";    //使用    List list = jt.query(sql, new NpcRowMapper());    return list; } /** * 定義內部類實現RowMapper介面 */ public class NpcRowMapper implements RowMapper{       //實現mapRow方法      public Object mapRow(ResultSet rs, int num) throws SQLException {         //對類進行封裝       TNpc npc = new TNpc();       npc.setId(rs.getLong("id"));       npc.setName(rs.getString("name"));       return npc;    }      } }

try
{
   messagebox.show("true");
}
catch
{
   messagebox.show("false");
}
finally
{
   messagebox.show("finally");
}

try 
{ 
//執行的程式碼，其中可能有異常。一旦發現異常，則立即跳到catch執行。否則不會執行catch裡面的內容 
} 
catch 
{ 
//除非try裡面執行程式碼發生了異常，否則這裡的程式碼不會執行 
} 
finally 
{ 
//不管什麼情況都會執行，包括try catch 裡面用了return ,可以理解為只要執行了try或者catch，就一定會執行 finally 
}