第14天dbutils與案例
第14天dbutils與案例 1
1. 1.dbutils介紹 2
2. 2.dbutils快速入門 2
3. 3.dbutils API詳解-DbUtils類 2
4. 4.dbutils API詳解-QueryRunner類 2
5. 5.dbutils API詳解-ResultSetHandler 3
6. 6.ResultSetHandler實現類介紹 3
7. 7.案例--添加商品分析 3
8. 8.案例--添加商品實現 4
9. 9.案例--查詢全部分析 4
10. 10.案例--查詢全部實現 4
11. 11.案例--修改分析 4
12. 12.案例--修改實現 4
如何學習新技術：
DBUtils是什麼?
作用：幫助java程序員，開發Dao層代碼的簡單框架。
框架作用：它是幫助程序員，提高開發效率的工具。（木工師傅，鋸子，錘子。。。）
JDBC幾技術本身是可以開發dao層代碼，那麼為什麼還需要學習，DBUtils？
JDBC技術的弊端分析：
回顧day13項目中JDBC代碼：
需求：操作jdbc數據庫，操作user表，獲取user表中所有的數據
代碼演示：
// 需求：獲取當前user表中所有的數據
public List<User> findAllUser() {
// 定義一個鏈接對象
Connection conn = null;
// 定義一個操作sql語句的對象
PreparedStatement stmt = null;
// 定義一個封裝結果集的對象
ResultSet rs = null;
try {
conn = JDBCUtils.getConnection();
String sql = "select * from user";
stmt = conn.prepareStatement(sql);
rs = stmt.executeQuery();
// 准備一個list集合，保存User對象
List<User> list = new ArrayList<User>();
while (rs.next()) {
User u = new User();
u.setAddress(rs.getString("address"));
u.setAge(rs.getInt("age"));
u.setBirthday(rs.getDate("birthday"));
u.setDescription(rs.getString("description"));
u.setEmail(rs.getString("email"));
u.setHobby(rs.getString("hobby"));
u.setId(rs.getInt("id"));
u.setName(rs.getString("name"));
u.setPassword(rs.getString("password"));
u.setSex(rs.getString("sex"));
list.add(u);
}
return list;
} catch (SQLException e) {
e.printStackTrace();
return null;
} finally {
// 釋放資源
JDBCUtils.release(rs, stmt, conn);
}
}
JDBC弊端：
導致：程序員在開發的時候，大量的重復勞動。開發的周期長，效率低
DBUtils：它主要是封裝了JDBC的代碼，簡化了dao層的操作。
它主要是封裝了JDBC的代碼——DBUtils的底層還是JDBC，做了一次簡單的封裝方便程序員使用。
DBUtils由Apache公司提供——一個需要Java程序員關注的公司。雲計算，谷歌三篇論文，hadoop——大數據技術。
阿裡巴巴技術——大型分布式電商網站，技術特點，能解決高並發，高可用問題
B2B 企業與企業 做生意（電商平台）
B2C 天貓 企業與個人用戶（電商平台）
C2C 個人與個人 淘寶（電商平台）
阿裡雲開發者平台，共享了阿裡的電商開發的很多技術（雲計算，雲存儲，海量數據分析，智能推薦。。。。。）
學習新技術的思路：
下載：DBUtils——http://commons.apache.org/proper/commons-dbutils/
去下載頁面：
解壓：
解壓後：
學習一個類方式：
定義：
構造函數：
DbUtils()
成員函數：
總結：DbUtils，它是一個控制連接，控制事物，控制驅動加載的一個類。
注意：今天使用C3P0連接數據庫，所以不使用DbUtils類，但是，在關閉資源的時候，會使用到DbUtils，而且這個DbUtils關閉資源的方法，是框架自動調用，不需要程序員，書寫java代碼，手動調用。
老師既然不用，為何要學？
作為一個JDBC框架（操作數據庫），肯定需要有加載驅動，獲取連接，關閉資源的方法，所以DBUtils技術，設計了一個類（DbUtils）.
那以後我要不要使用DbUtils類？
一般來說，不用，以後開發，使用框架，框架內部一般都使用C3P0連接數據庫
定義：
構造函數：
QueryRunner()：創建一個與數據庫無關的queryRunner對象，後期在操作數據庫的時候，需要手動給一個Connection對象，它可以手動控制事物。
Connection.setAutoCommit(false);設置手動管理事務
Connection.commit();提交事務
QueryRunner(DataSource ds)：創建一個與數據庫關聯的queryRunner對象，後期在操作數據庫的時候，不需要Connection對象，自動管理事物。
DataSource參數:就是c3p0數據庫連接池對象
c3p0數據庫連接池對象，它實現類java.sql.DateSource這個接口
ComboPooledDataSource extends AbstractPoolBackedDataSource implements PooledDataSource
PooledDataSource：PooledDataSource extends DataSource
成員方法：
增刪改方法：
update(Connection conn, String sql, Object... params)：這是執行添加，修改和刪除sql語句的方法，三個參數（數據庫連接，sql語句，sql語句的參數）
update(String sql, Object... params)：這是執行添加，修改和刪除sql語句的方法，兩個參數（sql語句，sql語句的參數）
查詢的方法
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)：這是執行查詢sql語句的方法，四個參數（數據庫連接，sql語句，封裝數據的策略對象，sql語句的參數）
query(String sql, ResultSetHandler<T> rsh, Object... params)：這是執行查詢sql語句的方法，三個參數（sql語句，封裝數據的策略對象，sql語句的參數）
構造函數與增刪改查方法的組合：
QueryRunner()
update(Connection conn, String sql, Object... params)
query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
QueryRunner(DataSource ds)
update(String sql, Object... params)
query(String sql, ResultSetHandler<T> rsh, Object... params)
策略：封裝數據到對象的方式（示例：將數據保存在User、保存到數組、保存到集合）
定義：
方法介紹：
注意：詳解參考ResultSetHandler實現類介紹
代碼演示:
//需求：向user表插入一條數據
@Test
public void test1(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "insert into user values(null,?,?)";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
int update = qr.update(sql, "狗蛋","123456");
System.out.println(update);
} catch (SQLException e) {
e.printStackTrace();
}
}
//需求：修改id==7的數據
@Test
public void test2(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "update user set name = ? where id = ?";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
int update = qr.update(sql, "柳巖",7);
System.out.println(update);
} catch (SQLException e) {
e.printStackTrace();
}
}
//需求：刪除id==7的數據
@Test
public void test3(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "delete from user where id = ?";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
int update = qr.update(sql, 7);
System.out.println(update);
} catch (SQLException e) {
e.printStackTrace();
}
}
自定義策略：
package cn.itcast.handler;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbutils.ResultSetHandler;
import cn.itcast.domain.User;
// ResultSetHandler<T>,<T>表示封裝結果的類型
//MyHandler 是自定義的ResultSetHandler封裝結果集策略對象
public class MyHandler implements ResultSetHandler<List<User>>{
@Override
public List<User> handle(ResultSet rs) throws SQLException {
//封裝數據，數據從Resultset中獲取
List<User> list = new ArrayList<User>();
while(rs.next()){
User u = new User();
u.setId(rs.getInt("id"));
u.setName(rs.getString("name"));
u.setPwd(rs.getString("pwd"));
list.add(u);
}
return list;
}
}
測試代碼：
//需求：獲取user表中所有的數據
@Test
public void test4(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
List<User> list = qr.query(sql, new MyHandler());
System.out.println(list);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
總結：
1)創建queryRunner對象，用來操作數據庫
2)設置一個sql語句，用來操作數據庫
3)根據sql語句，執行相應的方法（insert 、 delete 、update===== update方法 || select=====query方法）
實現類的學習方式：先測試，根據測試結果，總結當前實現類的按照什麼樣的方式封裝數據（策略）
//需求：測試ArrayHandler策略
//ArrayHandler:將查詢結果的第一行數據，保存到Object數組中
@Test
public void test5(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Object[] objects = qr.query(sql, new ArrayHandler());
for (Object object : objects) {
System.out.println(object);
}
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試ArrayListHandler策略
//ArrayListHandler:將查詢的結果，每一行先封裝到Object數組中，然後，將數據存入list集合
@Test
public void test6(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
List<Object[]> list = qr.query(sql, new ArrayListHandler());
for (Object[] objects : list) {
for (Object object : objects) {
System.out.println(object);
}
System.out.println("=====");
}
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試BeanHandler策略
//BeanHandler:將查詢結果的第一行數據，封裝到user對象
@Test
public void test7(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
User user = qr.query(sql, new BeanHandler<User>(User.class));
System.out.println(user);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試BeanListHandler策略
//BeanListHandler:將查詢結果的每一行封裝到user對象，然後，再存入list集合
@Test
public void test8(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
List<User> list = qr.query(sql, new BeanListHandler<User>(User.class));
System.out.println(list);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試ColumnListHandler策略
//ColumnListHandler:將查詢結果的指定列的數據封裝到list集合中
@Test
public void test9(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Object object = qr.query(sql, new ColumnListHandler(2));
System.out.println(object);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試MapHandler策略
//MapHandler:將查詢結果的第一行數據封裝到map集合（key==列名，value==列值）
@Test
public void test10(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Map<String, Object> map = qr.query(sql, new MapHandler());
System.out.println(map);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試MapListHandler策略
//MapListHandler:將查詢結果的每一行封裝到map集合（key==列名，value==列值），再將map集合存入list集合
@Test
public void test11(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
List<Map<String, Object>> list = qr.query(sql, new MapListHandler());
System.out.println(list);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試BeanMapHandler策略
//BeanMapHandler:將查詢結果的每一行數據，封裝到User對象，再存入map集合中（key==指定的列值，value==User）
@Test
public void test12(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Object object = qr.query(sql, new BeanMapHandler(User.class,2));
System.out.println(object);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試KeyedHandler策略
//KeyedHandler:將查詢結果的每一行數據，封裝到map1集合（key==列名，value==列值），然後，將map1集合（有多個）存入map2集合（只有一個）
//map2集合（key==指定的列，value==map1集合）
@Test
public void test13(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select * from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Object object = qr.query(sql, new KeyedHandler());
System.out.println(object);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
//需求：測試ScalarHandler策略
//ScalarHandler:封裝類似count、avg、max、min、sum。。。。函數的執行結果
@Test
public void test14(){
//第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//第二步：創建sql語句
String sql = "select count(*) from user";
//第三步：執行sql語句,params:是sql語句的參數
//注意，給sql語句設置參數的時候，按照user表中字段的順序
try {
Object object = qr.query(sql, new ScalarHandler());
System.out.println(object);
} catch (SQLException e) {
e.printStackTrace();
}
}
效果：
DBUtils總結：
練習案例——用戶聯系人管理系統
需求：
功能列表：
注冊
登陸
查詢所有聯系人
按條件查詢聯系人
添加聯系人
刪除聯系人
修改聯系人
分頁展示數據
權限：1）在servelt 中做if判斷
2）將權限的數據保存在配置文件中，用戶請求的時候，根據配置文件查看用戶是否具有權限。
3）使用數據庫實現權限管理，涉及5張表
補充內容（MD5加密分析）：
JDK API:
獲取對象的API：
加密的API：
代碼演示：
package cn.itcast.utils;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
* @author wjn
* MD5加密工具類
*/
public class MD5Utils {
public static String getPwd(String pwd){
//創建加密對象
try {
MessageDigest digest = MessageDigest.getInstance("md5");
//調用加密對象的方法,加密的動作已經完成
byte[] bs = digest.digest(pwd.getBytes());
//接下來，我們要對加密後的結果，進行優化，按照mysql的優化思路走
//mysql的優化思路:
//第一步：將數據全部轉換成正數
String hexString = "";
for (byte b : bs) {
//b，它本來是一個byte類型的數據
//255,是一個int類型的數據
//b與255進行運算之後，會自動類型提升為int類型
//b 1001 1100 原來
//b 0000 0000 0000 0000 0000 0000 1001 1100
int temp = b & 255;
//第二步：將所有的數據，轉換成16進制的形式 1F 2B 3c
//第三步：解決任意數據，都要輸出一個固定長度的字符串
if(temp < 16 && temp >= 0){
//如果進入判斷，表示當前數據，不能轉換成兩位的16進制格式
//那麼，我們可以，手動補上一個"0"
hexString = hexString +"0"+ Integer.toHexString(temp);
}else{
hexString = hexString + Integer.toHexString(temp);
}
}
return hexString;
} catch (NoSuchAlgorithmException e) {
//NoSuchAlgorithmException沒有這個加密的算法
e.printStackTrace();
return "";
}
}
public static void main(String[] args) {
String pwd = MD5Utils.getPwd("abc");
System.out.println(pwd);
//工具類加密結果： 900150983cd24fb0d6963f7d28e17f72
//mysql加密結果：900150983cd24fb0d6963f7d28e17f72
}
}
效果：
開展工作：
准備工作：
1）創建數據庫
2）創建web工程
3）導入jar包（mysql驅動包、c3p0jar包、DBUtils包、BeanUtils包）
為什麼要記住jar包？
Jar包對應的都是技術，使用什麼jar包，使用什麼技術。
後期，使用maven技術管理項目的jar包，使用pom.xml文件管理jar包
他在管理的時候，都是通過jar包的名稱去管理。
4）c3p0-config.xml配置文件
6）創建與數據庫表對應的javabean
User類：用戶實體
Contact類：聯系人實體類
注冊的功能需求明確：
1）用戶的操作是什麼?
在頁面上輸入注冊的信息
提交注冊信息
2）頁面需要哪些東西？
需要一個表單，讓用戶可以輸入注冊信息
需要一個提交按鈕，將數據發送到服務器
3)服務器如何處理請求？
Servlet要做什麼？
獲取用戶請求數據（注冊信息）
對驗證碼做校驗，不通過，返回注冊頁面，
通過，將數據封裝到User對象中
Service要做什麼？
判斷當前用戶名是否已經存在
存在，返回一個標記，告訴servlet，用戶名重復
不存在：
將用戶輸入的明文密碼進行加密，
調用dao注冊用戶
Dao要做什麼？
對service方法進行支持，注冊用戶到數據庫
4)給用戶什麼樣的響應？
根據不同的情況，給出不同的響應。
所有的情況：
驗證碼錯誤
用戶名已經存在
數據庫異常，服務器忙，請稍後再試
思考功能的實現基本思路：
老師:頁面可不可以寫表單的驗證，使用javascript技術?
答：可以，注意頁面的表單驗證，必須前端js驗證和後台java代碼驗證都需要執行。
頁面展示：
Servlet代碼：
package cn.itcast.web;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.beanutils.BeanUtils;
import cn.itcast.domain.User;
import cn.itcast.service.UserService;
import cn.itcast.service.impl.UserServiceImpl;
public class RegisterServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//第一步：接收請求
request.setCharacterEncoding("utf-8");
//第二步：驗證碼校驗
String checkImg = request.getParameter("checkImg");
String servletImg = (String)request.getSession().getAttribute("servletImg");
//提問：servletImg調用equeals方法好，還是checkImg調用equeals好？
//答：checkImg因為是用戶提交的數據，可能為null，容易發生空指針異常
if(servletImg.equalsIgnoreCase(checkImg)){
//驗證通過
//第三步：封裝數據
//bean:數據要被封裝到的對象（User）
//properties ：封裝了請求參數的map集合
User u = new User();
try {
BeanUtils.populate(u, request.getParameterMap());
} catch (Exception e) {
e.printStackTrace();
}
//單獨封裝hobby
String[] values = request.getParameterValues("hobby");
String hobby = "";
for (String string : values) {
hobby = hobby + ","+string;
}
hobby = hobby.substring(1);
u.setHobby(hobby);
//封裝數據完成
//第四步:調用service方法
//提問：老師，我自己寫的項目沒有使用接口，直接都是類之間調用，這樣可以嗎？
//答：不可以，如果是類之間調用，那麼你後期，要使用新的類替換原來的內容，那麼你需要修改servlet service dao
//如果使用接口開發，只需要替換實現類即可，操作簡單。
UserService userService = new UserServiceImpl();
int info = userService.register(u);
//第五步：根據不同返回值，不同處理
if(info == 1){
response.sendRedirect(request.getContextPath()+"/login.jsp");
return;
}else if(info == -1){
request.setAttribute("msg", "用戶名重復");
request.getRequestDispatcher("/register.jsp").forward(request, response);
return;
}else{
request.setAttribute("msg", "服務器已經很努力了，請在等我一下下");
request.getRequestDispatcher("/register.jsp").forward(request, response);
return;
}
}else{
//驗證不通過
request.setAttribute("msg", "驗證碼錯誤");
request.getRequestDispatcher("/register.jsp").forward(request, response);
return;
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Service代碼：
接口：
package cn.itcast.service;
import cn.itcast.domain.User;
public interface UserService {
/**
* 注冊的方法
* @param u
* @return
*/
int register(User u);
}
實現類：
package cn.itcast.service.impl;
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
import cn.itcast.domain.User;
import cn.itcast.service.UserService;
import cn.itcast.utils.MD5Utils;
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public int register(User u) {
// TODO :標記當前的代碼寫到這裡，還沒有完成，請繼續完成
// 查詢用戶是否存在
User user = userDao.findUserByName(u.getName());
if(user != null){
return -1;
}else{
// 不存在，先將用戶的密碼進行加密，然後，注冊用戶
String pwd = MD5Utils.getPwd(u.getPassword());
u.setPassword(pwd);
return userDao.register(u);
}
}
}
Dao代碼：
接口：
package cn.itcast.dao;
import cn.itcast.domain.User;
public interface UserDao {
/**
* 根據用戶名查詢數據的方法
* @param name
* @return
*/
User findUserByName(String name);
/**
* 注冊的方法
* @param u
* @return
*/
int register(User u);
}
實現類：
package cn.itcast.dao.impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import cn.itcast.dao.UserDao;
import cn.itcast.domain.User;
import cn.itcast.utils.JDBCUtils;
public class UserDaoImpl implements UserDao {
@Override
public User findUserByName(String name) {
// 第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
// ctrl+shift+f 格式化代碼
// 第二步：創建sql語句
String sql = "select * from user where name = ?";
try {
User user = qr.query(sql, new BeanHandler<User>(User.class), name);
return user;
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("獲取用戶數據失敗");
}
//throw throws:方法聲明 try catch finally 處理異常關鍵字
}
@Override
public int register(User u) {
// 第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
// 第二步：創建sql語句
String sql = "insert into user values(null,?,?,?,?,?,?,?,?,?)";
//創建一個集合List，用來存放sql語句參數
List<Object> list = new ArrayList<Object>();
list.add(u.getName());
list.add(u.getPassword());
list.add(u.getAge());
list.add(u.getSex());
list.add(u.getEmail());
list.add(u.getHobby());
list.add(u.getAddress());
list.add(u.getDescription());
list.add(u.getBirthday());
try {
return qr.update(sql, list.toArray());
} catch (SQLException e) {
e.printStackTrace();
return -2;
}
}
}
畫圖分析：
Servlet代碼：
package cn.itcast.web;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.itcast.domain.User;
import cn.itcast.service.UserService;
import cn.itcast.service.impl.UserServiceImpl;
public class LoginServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
//接收請求的參數
String username = request.getParameter("username");
String pwd = request.getParameter("pwd");
//調用service方法
UserService userService = new UserServiceImpl();
User loginUser = userService.login(username,pwd);
if(loginUser == null){
request.setAttribute("msg", "用戶名或者密碼錯誤");
request.getRequestDispatcher("/login.jsp").forward(request, response);
return;
}else{
//獲取方法的返回值，將數據保存到session，跳轉歡迎頁面
request.getSession().setAttribute("loginUser", loginUser);
response.sendRedirect(request.getContextPath()+"/welcome.jsp");
return;
}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Service代碼：
接口：
/**
* 用戶登錄的方法
* @param username
* @param pwd
* @return
*/
User login(String username, String pwd);
實現類：
public User login(String username, String pwd) {
//加密密碼
String password = MD5Utils.getPwd(pwd);
//登陸用戶
return userDao.login(username,password);
}
DAO代碼
接口：
/**
* 用戶登錄的方法
* @param username
* @param password
* @return
*/
User login(String username, String password);
實現類：
public User login(String username, String password) {
// 第一步：創建queryRunner對象，用來操作sql語句
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
// ctrl+shift+f 格式化代碼
// 第二步：創建sql語句
String sql = "select * from user where name = ? and password = ?";
try {
return qr.query(sql, new BeanHandler<User>(User.class), username,password);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("登陸用戶失敗");
}
}
補充（記住用戶名）——希望大家可以課余時間完成：
