專案搭建

  • 專案連結https://gitee.com/zhangjzm/smbms.git
  • 前置知識，Servlet JSP

結構圖

搭建maven web專案

  • 1.搭建一個maven web專案

  • 2.配置tomcat

  • 3.測試專案是否能跑起來

  • 4.匯入專案中遇到的jar包

    • jsp，servlet，mysql驅動，jstl，standard

  • 5.建立專案包結構

  • 6.編寫實體類

    • ORM對映：表-類對映

  • 7.編寫基礎公共類

    • 1）資料庫配置檔案
    • 2)編寫資料庫的公共類

  • ------四部曲，1.使用Properties（IO流）獲取連線資料 2.進行連線 3.執行體（ResultSet或int） 4.關閉流

  • Properties物件類似Key Value取值

  • InputStream inputStream = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");

  • 類載入器 .class.getClassLoader().getResourceAsStream取值

  • properties.load(inputStream);//IO流取值

  • 本質----------------獲取資料庫資料

POJO --- 提供一個實體，對物件的基本操作啊，set，get值

Dao --- 提供資料-怎麼提供？--依照你輸入的引數獲取想要的返回（返回物件需new物件）

Service --- 資料處理--怎麼處理？--引入dao，拿到dao的資料封裝一下（這麼做的意義？Controller直接拿dao不好嗎？）

作用：---實現本層資料共享（不同controller都可以呼叫Service）---1.獲取資料---2.對資料進行處理，如：判別，對資料進行計算

怎麼處理的？ 通過入參啊，然後呼叫dao的進行處理啊。。。

  • 答：1.從引入dao來說，如果你直接由controller來進行，那麼DAO發生替換（比如從oracle遷移mysql），需要找到所有controller裡的呼叫點，逐一修改。
  • 2.如果每個判別，操作都由controller來進行，那麼同層的controller並不能互通（處理資料），比如：折扣計算，反作弊判定

Controller

  1.   package com.zjz.dao;
  3.   import java.io.IOException;
  4.   import java.io.InputStream;
  5.   import java.sql.*;
  6.   import java.util.Properties;
  8.   //操作資料庫的公共類
  9.   public class BaseDao {
  10.       private static String driver;
  11.       private static String url;
  12.       private static String username;
  13.       private static String password;
  15.       //靜態程式碼塊，類載入的時候就初始化
  16.       static {
  17.           Properties properties = new Properties();
  18.           //通過類載入器讀取對應的資源
  19.           InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");
  20.           try {
  21.               properties.load(is);
  22.           } catch (IOException e) {
  23.               e.printStackTrace();
  24.           }
  26.           driver = properties.getProperty("driver");
  27.           url = properties.getProperty("url");
  28.           username = properties.getProperty("username");
  29.           password = properties.getProperty("password");
  31.       }
  33.       //獲取資料的連線
  34.       public static Connection getConnection(){
  35.           Connection connection = null;
  36.           try {
  37.               Class.forName(driver);
  38.               connection = DriverManager.getConnection(url,username,password);
  39.           } catch (Exception e) {
  40.               e.printStackTrace();
  41.           }
  42.           return connection;
  43.       }
  45.       //編寫查詢公共類
  46.       public static ResultSet execute(Connection connection,String sql,Object[] params,ResultSet resultSet, PreparedStatement preparedStatement) throws SQLException {
  47.           preparedStatement = connection.prepareStatement(sql);
  48.           int len = params.length;
  49.           for(int i = 0;i<len;i++){
  50.               //setObject 佔位符從1開始，陣列是從0開始
  51.               preparedStatement.setObject(i+1,params[i]);
  52.           }
  53.           resultSet = preparedStatement.executeQuery();
  54.           return resultSet;
  55.       }
  57.       //編寫增刪改公共方法
  58.       public static int execute(Connection connection,String sql,Object[] params, PreparedStatement preparedStatement) throws SQLException {
  59.           preparedStatement = connection.prepareStatement(sql);
  60.           int len = params.length;
  61.           for(int i = 0;i<len;i++){
  62.               //setObject 佔位符從1開始，陣列是從0開始
  63.               preparedStatement.setObject(i+1,params[i]);
  64.           }
  65.           int updateRows = preparedStatement.executeUpdate();
  66.           return updateRows;
  67.       }
  69.       //釋放資源
  70.       public static boolean closeResource(Connection connection,ResultSet resultSet, PreparedStatement preparedStatement){
  71.           boolean flag = true;
  72.           if(resultSet!=null){
  73.               try {
  74.                   resultSet.close();
  75.                   //GC回收
  76.                   resultSet = null;
  77.               } catch (SQLException throwables) {
  78.                   throwables.printStackTrace();
  79.                   flag = false;
  80.               }
  81.           }
  83.           if(connection!=null){
  84.               try {
  85.                   connection.close();
  86.                   //GC回收
  87.                   connection = null;
  88.               } catch (SQLException throwables) {
  89.                   throwables.printStackTrace();
  90.                   flag = false;
  91.               }
  92.           }
  94.           if(preparedStatement!=null){
  95.               try {
  96.                   preparedStatement.close();
  97.                   //GC回收
  98.                   preparedStatement = null;
  99.               } catch (SQLException throwables) {
  100.                   throwables.printStackTrace();
  101.                   flag = false;
  102.               }
  103.           }
  105.       return flag;
  106.       }
  108.   }
  • 8.編寫字元編碼過濾器

    • Filter類
    • web配置

功能一 登入功能的實現

編寫

  • 1.編寫前端
  • 2.設定首頁，web.xml
  1.   <!--設定歡迎頁面-->
  2.     <welcome-file-list>
  3.         <welcome-file>/login.jsp</welcome-file>
  4.     </welcome-file-list>
  • 3.編寫dao層，使用者登入的介面
  1.   public interface UserDao {
  2.       //得到要登入的使用者
  3.       public User getLoginUser(Connection connection,String userCode) throws SQLException;
  4.   }
  • 4.編寫dao介面實現類
  1.   public class UserDaoImpl implements UserDao{
  2.     public User getLoginUser(Connection connection, String userCode) throws SQLException {
  4.         PreparedStatement pstm = null;
  5.         ResultSet rs = null;
  6.         User user = null;
  7.         if(connection != null){
  8.             String  sql = "select * from smbms_user where userCode = ?";
  9.             Object[] params = {userCode};
  11.             rs = BaseDao.execute(connection, pstm, rs, sql, params);
  12.             if(rs.next()){
  13.                 user = new User();
  14.                 user.setId(rs.getInt("id"));
  15.                 user.setUserCode(rs.getString("userCode"));
  16.                 user.setUserName(rs.getString("userName"));
  17.                 user.setUserPassword(rs.getString("userPassword"));
  18.                 user.setGender(rs.getInt("gender"));
  19.                 user.setBirthday(rs.getDate("birthday"));
  20.                 user.setPhone(rs.getString("phone"));
  21.                 user.setAddress(rs.getString("address"));
  22.                 user.setUserRole(rs.getInt("userRole"));
  23.                 user.setCreatedBy(rs.getInt("createdBy"));
  24.                 user.setCreationDate(rs.getTimestamp("creationDate"));
  25.                 user.setModifyBy(rs.getInt("modifyBy"));
  26.                 user.setModifyDate(rs.getTimestamp("modifyDate"));
  28.             }
  29.             BaseDao.closeResource(null,pstm,rs);
  31.         }
  32.         return user;
  33.     }
  34.  }
  • 5.業務層介面 
    1.   public interface UserService {
    2.   //使用者登入
    3.   public User login(String userCode, String password);
    4. }
  • 6.業務層實現類
  1.   public class UserServiceImpl implements UserService{
  3.       //業務層都會呼叫dao層，所以我們要引入dao層
  4.       private UserDao userDao;
  5.       public UserServiceImpl() {
  6.           userDao = new UserDaoImpl();
  7.       }
  8.       public User login(String userCode, String password) {
  9.           Connection connection = null;
  10.           User user = null;
  11.           try {
  12.               connection = BaseDao.getConnection();
  13.               //通過業務層呼叫具體的資料庫操作
  14.               user = userDao.getLoginUser(connection,userCode);
  15.           } catch (SQLException throwables) {
  16.               throwables.printStackTrace();
  17.           }finally {
  18.               BaseDao.closeResource(connection,null,null);
  19.           }
  20.           return user;
  21.       }
  23.       @Test
  24.       public void test(){
  25.           UserServiceImpl userService = new UserServiceImpl();
  26.           User wen = userService.login("wen", "123");
  27.           System.out.println("密碼為：" + wen.getUserPassword());
  29.       }
  30.   }
  • 7.servlet層實現
  1.   public class LoginServlet extends HttpServlet {
  3.       //Servlet:控制層，呼叫業務層程式碼
  4.       @Override
  5.       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  6.           System.out.println("LoginServlet---start");
  7.           //獲取使用者的使用者名稱和密碼
  8.           String userCode = req.getParameter("userCode");
  9.           String userPassword = req.getParameter("userPassword");
  11.           //和使用者資料庫中的密碼對比，呼叫業務層
  12.           UserService userService = new UserServiceImpl();
  13.           User user = userService.login(userCode, userPassword);//登入的人查出來
  15.             if(user != null&&(user.getUserPassword().equals(userPassword))){//查到有這個人
  16.               //將使用者的資訊放到session中
  17.               req.getSession().setAttribute(Constants.USER_SESSION,user);
  18.               //跳轉到主頁
  19.               resp.sendRedirect("jsp/frame.jsp");
  20.           }else {//查無此人
  21.               //轉發回登入頁面，並提示錯誤
  22.               req.setAttribute("error","使用者名稱，密碼不正確");
  23.               req.getRequestDispatcher("login.jsp").forward(req,resp);
  24.           }
  25.       }
  27.       @Override
  28.       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  29.           doGet(req, resp);
  30.       }
  31.   }
  • 8.註冊servle
  1.      <servlet>
  2.         <servlet-name>LoginServlet</servlet-name>
  3.         <servlet-class>com.zjz.servlet.user.LoginServlet</servlet-class>
  4.     </servlet>
  5.     <servlet-mapping>
  6.         <servlet-name>LoginServlet</servlet-name>
  7.         <url-pattern>/login.do</url-pattern>
  8.     </servlet-mapping>
  • 9.編寫過濾器，攔截沒登入的
  1.   public class SysFilter implements Filter {
  2.       public void init(FilterConfig filterConfig) throws ServletException {
  3.       }
  5.       public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  6.           HttpServletRequest request = (HttpServletRequest) servletRequest;
  7.           HttpServletResponse response = (HttpServletResponse)servletResponse;
  8.           //從session中獲取使用者
  9.           User user = (User) request.getSession().getAttribute(Constants.USER_SESSION);
  10.           if(user==null){//說明已經登出了
  11.               response.sendRedirect("/error.jsp");
  12.           }else {
  13.               filterChain.doFilter(servletRequest,servletResponse);
  14.           }
  15.       }
  17.       public void destroy() {
  18.       }
  19.   }
  1.   <!--使用者登入過濾器-->
  2.     <filter>
  3.         <filter-name>SysFilter</filter-name>
  4.         <filter-class>com.zjz.Filter.SysFilter</filter-class>
  5.     </filter>
  6.     <filter-mapping>
  7.         <filter-name>SysFilter</filter-name>
  8.         <url-pattern>/jsp/*</url-pattern>
  9.     </filter-mapping>
  • 10.由底層向上層寫

功能二，修改密碼-修當前的

修改所有的，還是修改當前的---兩個可以呼叫同一個DAO（修改），但業務就不一樣了吧，修當前的id需要通過session獲取吧。

編寫

  • 設定文字型別

    resp.setContentType("application/json"); // setContentType 設定文字的型別

功能三，使用者介面

編寫

看到的頁面顯示多少條，當前頁碼，都得與當前的使用者list繫結

每次點選切換的時候也就是再次執行SQL進行分頁的處理，並不是同一批資料分割開。。。（可利用前端進行分割--）

所以總數量的獲取需要單獨寫一個SQL

總數量的作用就是，幫助我們顯示有幾頁

跳轉由前端獲取頁數，或者上一頁，下一頁由前端引數直接控制

  • 總體思路，使用者展示

    • List<User> userList = userService.getUserList(queryUserName, queryUserRole, currentPageNo, pageSize);
    • 總數量--返回一個總數量
    • 分頁Bean 專用於分頁。。也就是一個服務類，利用總數量服務currentPageNo動態變化

  • 1.匯入分頁的工具類

  • 2.使用者列表的匯入

    • userlist.jsp

  • 1.獲取使用者數量

    • UserDao UserDaoImpl UserService UserServiceImpl

  • 2.分頁的邏輯

    • 在資料庫中分頁使用 Limit startIndex，pageSize; 總數
    • 0,5--第1頁-- 6,5--第2頁-- 11,5--第3頁----每頁五個
    • 當前頁 （當前頁-1） * 頁面大小

  • 3.獲取使用者列表

    • userdao

    2.       public List<User> getUserList(Connection connection,String username,int userRole,int currentPageNo,int pageSize)throws Exception;
    • userdaoImpl UserService UserServiceImpl

  • 4.使用者顯示的servlet

    • 1.獲取使用者前端的資料（查詢）
    • 2.判斷請求是否需要執行，看引數的值判斷
    • 3.為了實現分頁，需要計算當前頁面的總頁面，以及頁面大小
    • 4.使用者前端展示
    • 5.返回前端
  1.               -------- 更多學習  https://zhangjzm.gitee.io/self_study