数据库操作方法总结

解决办法：

端口号错误。

初学者可以这么搞，坚持半年，效果显著。

1. 释放资源的时候

   我们需要从外往里面依次释放，与你声明的时候相反。就像人们穿衣服一样，然后脱衣服，效果类似。

2. 有些sql语句没有参数，怎么办

   遍历数组，需要判断，有些语句不需要赋值。所以需要先判断是否需要赋值，所以先判断是否为空。

   参考资料：http://zhidao.baidu.com/link?url=wT5zIOjpPQzE3pfAjPC-DZAlnEAO89O2ihgLT8SpFCKaXtktcBELHO5iRKeasUkMF8Wt0W__nhdMjK6-3i4-J_

3. 分层

   系统架构的解耦，主要是为了今后的扩展。因为 今天的项目 需求变更多，项目大。

   表示层：jsf structs2.0 门窗

   框架： spring 骨骼

   持久层：hibernate

   层与层之间是松耦合的。

   三层：

   Web层 ， service层， DAO层 表示层，服务层，数据访问层

   Web层调用service层；服务层调用dao层。

   必须先有，才能调用。所以，编程从后往前。

   生产与使用分离。想象一下 主板与内存条的关系。

   无缘无故多搞出来一层，其目的是上面一层DAO层几乎不怎么动，而service层只需调用即可。也就是说，我们多了一个interface层。

   

   访问数据库的工具在util中，我如何在impl中使用工具

   1. 实例化一个对象
   2. 继承工具类，继承过来就是我的，我就可以直接使用了。

错误：

你在程序中操作的长度大于在数据库当中的长度

因为我在设计数据库表的时候，sex的长度只有1，而我在程序里面赋值为男，为两个字符。所以，长度不一致。

当然，还有其他一些错误：比如长度不一致，顺序不一致。 ？ 与 param必须严格一致。一个？ 对应一个变量。一个参数，这样才可以。

新闻栏目添加 、 修改、查询（）、删除（新闻栏目下面有很多新闻内容，先删除内容，再删除栏目）

下面讲讲规范：

一般 我们开发分为几层。DAO层 一般放接口

下面以UserInfo这张表为例，讲讲MVC金典操作。

1. 首先建立实体类

   实体类的建立，依据数据库表中的字段而来的。下面是这些数据库表中的字段名。

   然后，通过eclipse 生成getter 和 setter 方法。程序如下面所示。

1. package com.buu.news.day3.entity;
2.  
3. public class UserInfo {
4.     private String userID;
5.     private String UserRealName;
6.     private String sex;
7.     private String birth;
8.     private String famillyaddress;
9.     private String email;
10.     private String tel;
11.     private String userLoginName;
12.     private String regDate;
13.     private String userPasword;
14.     private String conform;
15.     private String flag;
16.    public String getUserID() {
17.       return userID;
18.    }
19.    public void setUserID(String userID) {
20.       this.userID = userID;
21.    }
22.    public String getUserRealName() {
23.       return UserRealName;
24.    }
25.    public void setUserRealName(String userRealName) {
26.       UserRealName = userRealName;
27.    }
28.    public String getSex() {
29.       return sex;
30.    }
31.    public void setSex(String sex) {
32.       this.sex = sex;
33.    }
34.    public String getBirth() {
35.       return birth;
36.    }
37.    public void setBirth(String birth) {
38.       this.birth = birth;
39.    }
40.    public String getFamillyaddress() {
41.       return famillyaddress;
42.    }
43.    public void setFamillyaddress(String famillyaddress) {
44.       this.famillyaddress = famillyaddress;
45.    }
46.    public String getEmail() {
47.       return email;
48.    }
49.    public void setEmail(String email) {
50.       this.email = email;
51.    }
52.    public String getTel() {
53.       return tel;
54.    }
55.    public void setTel(String tel) {
56.       this.tel = tel;
57.    }
58.    public String getUserLoginName() {
59.       return userLoginName;
60.    }
61.    public void setUserLoginName(String userLoginName) {
62.       this.userLoginName = userLoginName;
63.    }
64.    public String getRegDate() {
65.       return regDate;
66.    }
67.    public void setRegDate(String regDate) {
68.       this.regDate = regDate;
69.    }
70.    public String getUserPasword() {
71.       return userPasword;
72.    }
73.    public void setUserPasword(String userPasword) {
74.       this.userPasword = userPasword;
75.    }
76.    public String getConform() {
77.       return conform;
78.    }
79.    public void setConform(String conform) {
80.       this.conform = conform;
81.    }
82.    public String getFlag() {
83.       return flag;
84.    }
85.    public void setFlag(String flag) {
86.       this.flag = flag;
87.    }
88.  
89. }
    1. 建立UserInfo这个表的接口层，定义一些个操作，我们称之为用户操作接口。主要完成 用户登录、删除、修改、查询和插入新的用户等操作。

       操作如下：

90. package com.buu.news.day3.dao;
91.  
92. import java.sql.ResultSet;
93.  
94. import com.buu.news.day3.entity.UserInfo;
95.  
96. /*
97.  * 用户操作接口
98.  * 1、登录操作
99.  * 2、删除操作
100.  * 3、修改操作
101.  * 4、查询操作
102.  * 5、插入新的用户操作
103.  */
104. public interface UserDao {
105. //需要先定义一个封装用户的实体类
106.    /*
107.      *1、 用户登录操作
108.     * 参数：用户对象
109.     * 返回值：true :登录成功
110.     * false:登录失败
111.     */
112.    public boolean userLogin(UserInfo user);
113.  
114.       /*
115.        *2、 删除用户操作
116.        * 参数：用户对象
117.        * 返回值：int : 0:不成功
118.        * !0 :成功
119.        */
120.    public int userDelete(UserInfo user);
121.  
122.       /*
123.        *3、 用户修改
124.        * 参数：用户对象
125.        * 返回值：int : 0:不成功
126.        * !0 :成功
127.        */
128.    public int userUpdate(UserInfo user);
129.  
130.       /*
131.        *4、 用户插入
132.        * 参数：用户对象
133.        * 返回值：int : 0:不成功
134.        * !0 :成功
135.        */
136.    public int userInsert(UserInfo user);
137.  
138.       /*
139.        *5、 用户查询
140.        * 参数：用户对象
141.        * 返回值：resultset集合
142.        *
143.        */
144.    public ResultSet userSelect(UserInfo user);
145.  
146. }
     1. 建立UserServiceDao的接口层，此层与上面的代码一样。只是增加了一个接口而已。
     2. 建立UserDaoImpl ,此类是UserDao的实现类，实现UerDao接口。

        代码如下：（里面有增删改查）

147. package com.buu.news.day3.dao.impl;
148.  
149. import java.sql.ResultSet;
150.  
151. import com.buu.news.day3.dao.UserDao;
152. import com.buu.news.day3.entity.UserInfo;
153. import com.buu.news.day3.util.ConnDB;
154.  
155. public class UserDaoImpl extends ConnDB implements UserDao {
156.  
157.    //public ConnDB conn = new ConnDB();
158.    public int userDelete(UserInfo user) {
159.       // TODO Auto-generated method stub
160.       String sql = "delete from userInfo where userID = ?"; //占位符？
161.       String[] param = {user.getUserID()}; //调用方法必须传数组
162.       int rtn = this.executeSQL(sql, param);
163.       if(rtn > 0)
164.          System.out.println("删除成功");
165.       else
166.          System.out.println("删除失败");
167.       return rtn;
168.    }
169.  
170.    public int userInsert(UserInfo user) {
171.       // TODO Auto-generated method stub
172.       String sql = "insert into userInfo values(?,?,?,?,?,?,?,?,?,?,?)";
173.       String[] param = {user.getUserRealName(),user.getSex(),user.getBirth(),user.getFamillyaddress(),user.getEmail(),user.getTel(),user.getUserLoginName(),user.getRegDate(),user.getUserPasword(),user.getConform(),user.getFlag()};
174.       int rtn = this.executeSQL(sql, param);
175.       if(rtn > 0)
176.          System.out.println("插入成功");
177.       else
178.          System.out.println("插入失败");
179.       return rtn;
180.    }
181.  
182.    public boolean userLogin(UserInfo user) {
183.       // TODO Auto-generated method stub
184.  
185.       return false;
186.    }
187.  
188.    public ResultSet userSelect(UserInfo user) {
189.       // TODO Auto-generated method stub
190.       String sql = "select * from userInfo where userID = ?";
191.       String[] param = {user.getUserID()};
192.       ResultSet rs = this.executeSelectSQL(sql,param);
193.       if(rs != null)
194.          System.out.println("查询成功");
195.       else
196.          System.out.println("查询失败");
197.       return rs;
198.    }
199.  
200.    public int userUpdate(UserInfo user) {
201.       // TODO Auto-generated method stub
202.       String sql = "update userInfo set userRealName = ?,sex = ?,birth = ?,fimallyAddress = ?,Email=?";
203.       sql += ",Tel=?,userLoginName=?,regDate=?,userPassword=?,confirm1=?,flog=? where userID=?";
204.       String[] param = {user.getUserRealName(),user.getSex(),user.getBirth(),user.getFamillyaddress(),user.getEmail(),user.getTel(),user.getUserLoginName(),user.getRegDate(),user.getUserPasword(),user.getConform(),user.getFlag(),user.getUserID()};
205.       int rtn = this.executeSQL(sql, param);
206.       if(rtn > 0)
207.          System.out.println("更新成功");
208.       else
209.          System.out.println("更新失败");
210.       return rtn;
211.    }
212.  
213. }

     其中，有几个关键的地方，需要提一下

     关键地方一：this.executeSelectSQL(sql,param); 和 this.executeSQL(sql, param); 这两句是增删改 与 查 分家的地方。我们可以定义工具类来实现顶层操作。

     这些顶层操作是工具，是可以重复利用的代码逻辑。

     关键地方二：为啥用this，其实这里面我们完全可以用类的实例化，然后再调用对象.方法来实现，这里却用到了上面的形式。我们在实现此接口的同事，还可以

     继承工具类，这样的话，我们就可以不用实例化了，这样的话，代码量可以进一步减少。健壮性又有所提高。

     1. 工具类 ConnDB

        代码如下：

214. package com.buu.news.day3.util;
215.  
216. import java.sql.Connection;
217. import java.sql.DriverManager;
218. import java.sql.PreparedStatement;
219. import java.sql.ResultSet;
220. import java.sql.SQLException;
221. import java.sql.Statement;
222.  
223. /*
224.  * 数据库基本操作
225.  * 1、获取连接对象
226.  * 2、释放相关资源
227.  * 3、数据库增删改查
228.  */
229. public class ConnDB {
230. //定义数据连接字符串，访问数据库用户名和密码
231.    public final static String driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
232.    public final static String url = "jdbc:sqlserver://localhost:1433;DataBaseName=NewsSystem";
233.    public final static String dbName = "sa";
234.    public final static String dbPa = "123456";
235.  
236.    /*1、获取数据库连接对象
237.     * 返回值：connection对象
238.     */
239.    public Connection getConn()
240.    {
241.       Connection conn = null;
242.       try {
243.          Class.forName(driver);
244.          conn = DriverManager.getConnection(url, dbName, dbPa);
245.          System.out.println("数据库连接成功");//提示的
246.       } catch (Exception e) { //为了使抛出的异常减少，抛出ClassNotFound的父类即可
247.          // TODO Auto-generated catch block
248.          e.printStackTrace();
249.       }//必须要有异常处理，增加程序的健壮性
250.       return conn;
251.    }
252.    /*释放连接数据库的所有资源
253.     * 资源包括：连接对象connection，statement对象，preparement对象，resultset对象
254.     */
255.    public void closeAll(Connection conn, Statement stmt, PreparedStatement pstmt, ResultSet rs)
256.    {
257.  
258.          try {
259.             if(rs!=null)
260.                rs.close();
261.             if(pstmt!=null)
262.                pstmt.close();
263.             if(stmt!=null)
264.             stmt.close();
265.             if(conn!=null)
266.                conn.close();
267.          } catch (SQLException e) {
268.             // TODO Auto-generated catch block
269.             e.printStackTrace();
270.          }
271.    }
272.    /*
273.     * 执行更新操作：插入、修改、删除（会有成功和失败）
274.     * 参数：sql语句; param:sql赋值参数
275.     * 返回值：int类型。sql语句对数据库影响的行数
276.     * 0：含义：插入、修改、删除失败
277.     */
278.    public int executeSQL(String sql, String[] param)
279.    {
280.       Connection conn = null;
281.       PreparedStatement pstmt = null;
282.       int rtn = 0;
283.       //处理sql语句，执行sql语句
284.       conn = this.getConn();// 里面已经有链接了
285.       try {
286.          pstmt = conn.prepareStatement(sql);//sql语句只有一条，但赋的值不只一条，避免重复造轮子
287.          if(param != null)
288.          {
289.             for(int i = 0; i < param.length; ++i)
290.             {
291.                pstmt.setString(i+1, param[i]);//为预编译的sql语句赋参数，语句下标从1开始。（数组里面的个数 就是 sql语句中占位符的个数，不过sql语句里面的下标从1开始，数组下标从0开始）
292.             }
293.          }
294.          //执行sql语句
295.          rtn = pstmt.executeUpdate(); //只有他返回int类型参数
296.  
297.       } catch (SQLException e) {
298.          // TODO Auto-generated catch block
299.          e.printStackTrace();
300.       }
301.       return rtn;
302.    }
303.    /*
304.     * 执行查询操作
305.     * 参数：sql语句; param:sql赋值参数
306.     * 返回值：ResultSet类型
307.     *
308.     */
309.    public ResultSet executeSelectSQL(String sql, String[] param)
310.    {
311.       Connection conn = null;
312.       PreparedStatement pstmt = null;
313.       //处理sql语句，执行sql语句
314.       conn = this.getConn();// 里面已经有链接了
315.       ResultSet rtn = null;
316.       try {
317.          pstmt = conn.prepareStatement(sql);//sql语句只有一条，但赋的值不只一条，避免重复造轮子
318.          if(param != null)
319.          {
320.             for(int i = 0; i < param.length; ++i)
321.             {
322.                pstmt.setString(i+1, param[i]);//为预编译的sql语句赋参数，语句下标从1开始。
323.             }
324.          }
325.          //执行sql语句
326.         rtn = pstmt.executeQuery(); //只有他返回int类型参数
327.  
328.       } catch (SQLException e) {
329.          // TODO Auto-generated catch block
330.          e.printStackTrace();
331.       }
332.       return rtn;
333.    }
334. }
     1. 创建数据库访问接口 ，这里 为UserServiceDaoImpl ,是UserServiceDao接口类的实现。

        程序里面只是一个接口而已，先实例化，然后返回一些个值。

335. package com.buu.news.day3.service.impl;
336.  
337. import java.sql.ResultSet;
338.  
339. import com.buu.news.day3.dao.UserDao;
340. import com.buu.news.day3.dao.impl.UserDaoImpl;
341. import com.buu.news.day3.entity.UserInfo;
342. import com.buu.news.day3.service.UserServiceDao;
343.  
344. public class UserServiceDaoImpl implements UserServiceDao {
345.  
346.    //创建数据库访问接口
347.    private UserDao userdao = new UserDaoImpl();
348.    public int userDelete(UserInfo user) {
349.       // TODO Auto-generated method stub
350.       int rtn = userdao.userDelete(user);
351.       return rtn;
352.    }
353.  
354.    public int userInsert(UserInfo user) {
355.       // TODO Auto-generated method stub
356.       int rtn = userdao.userInsert(user);
357.       return rtn;
358.    }
359.  
360.    public boolean userLogin(UserInfo user) {
361.       // TODO Auto-generated method stub
362.       boolean rtn = userdao.userLogin(user);
363.       return rtn;
364.    }
365.  
366.    public ResultSet userSelect(UserInfo user) {
367.       // TODO Auto-generated method stub
368.       ResultSet rs = userdao.userSelect(user);
369.       return rs;
370.    }
371.  
372.    public int userUpdate(UserInfo user) {
373.       // TODO Auto-generated method stub
374.       int rtn = userdao.userUpdate(user);
375.       return rtn;
376.    }
377.  
378. }

     以上搞定了 业务逻辑层调用 数据访问层， 后面开始搞 表示层调用 业务逻辑层。