高同学_Luka

书城项目详细整理

声明：书城项目来自尚硅谷web课程
具体源码：书城资源链接

JavaEE三层架构

第二阶段

1 先创建书城项目所需要的数据库和表

命令行启动mysql服务

net start mysql
mysql -uroot -p
******

#创建数据库
DROP DATABASE IF EXISTS book
CREATE DATABASE book

#使用数据库
USE book

#创建表t_user
CREATE TABLE t_user(
	`id` INT PRIMARY KEY AUTO_INCREMENT,
	`username` VARCHAR(20) NOT NULL UNIQUE,
	`password` VARCHAR(20) NOT NULL,
	`email` VARCHAR(100)
);

#插入管理员数据
INSERT INTO t_user(`username`,`password`,`email`)
VALUES('admin','admin','[email protected]');

SELECT * FROM t_user;

2 编写数据库表对应的JavaBean对象

在pojo包下面创建User类

package com.atgw.pojo;/*
 *  @author GaoWei
 *  Date  2021/1/1--13:59
 */

public class User {
    private Integer id;
    private String username;
    private String password;
    private String email;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public User() {
    }

    public User(Integer id, String username, String password, String email) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

3 编写工具类JdbcUtils

jdbc.properties配置文件

username=root
password=000519
url=jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf-8&useSSL=false&rewriteBatchedStatement=true
driverClassName=com.mysql.jdbc.Driver
#最小空闲连接数
initialSize=5
#最大连接数
maxActive=10

在utils包下面创建JdbcUtils类

public class JdbcUtils {

    //创建数据库连接池放在静态代码块中是为了只创建一个，因为当类加载的时候就会创建，且只创建一次
    private static DataSource dataSource;
    static {
        try { 
            //读取配置文件，返回输入流
            InputStream is = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties prop = new Properties();
            //加载流
            prop.load(is);
            //创建数据库连接池返回
            dataSource = DruidDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取连接
    //返回null说明获取连接失败
    public static Connection getConnection(){
        Connection con = null;
        try {
            con = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return con;
    }

    //关闭连接
    public static void closeConnection(Connection c){
        //连接非空时才需要关闭
        if(c!=null){
            try {
                c.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

测试JdbaUtils类

public class JdbcUtilsTest {

    @Test
    public void testJdbcUtils(){
        Connection connection = JdbcUtils.getConnection();
        System.out.println(connection);
    }
}

4 编写BaseDao

在dao.impl包下面创建一个抽象类,写一些表的通用操作(其他某种类可以继承使用里面的方法)

//声明为抽象类，写一些表的通用操作（不是特定的某张表）
public abstract class BaseDao {

    //使用DbUtils操作数据库
    //DbUtils封装了一些常用的方法，不用我们自己去写获取和关闭连接的方法
    //QueryRunner已经解决了Connection连接问题，
    private QueryRunner queryRunner = new QueryRunner();

    //修改一个表的数据
    //返回影响的行数
    public int update(String sql,Object...args){
        Connection connection = JdbcUtils.getConnection();
        try {
            return queryRunner.update(connection,sql,args);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.close(connection);
        }
        return -1;
    }

    //查询一行数据
    public <T> T queryForOne(Class<T> clazz,String sql,Object...args){
        Connection connection = JdbcUtils.getConnection();
        try {
            //返回一个对象
            return queryRunner.query(connection,sql,new BeanHandler<T>(clazz),args);
            //BeanHandler是ResultSetHandler接口的实现类，结果集的处理器
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.close(connection);
        }
        return null;
    }

    //查询多行数据
    public <T> List<T> queryForList(Class<T> clazz, String sql, Object...args){
        Connection connection = JdbcUtils.getConnection();
        try {
            return queryRunner.query(connection,sql,new BeanListHandler<T>(clazz),args);
            //BeanListHandler返回多个数据
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.close(connection);
        }
        return null;
    }

    //查询特殊的数据
    //比如一些集函数Count Avg
    public Object queryForSingleValue(String sql,Object...args){
        Connection connection = JdbcUtils.getConnection();
        try {
            //返回一个Object类型
            return queryRunner.query(connection,sql,new ScalarHandler());
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.close(connection);
        }
        return null;
    }
}

5 编写UserDao

接口UserDao

//用户在登录时我们需要做的三件事
//在接口中声明这些方法，在用户实现类中需要具体实现这些方法
public interface UserDao {

   //根据用户名查询是否存在（注册页面）
   //返回null说明不存在
   public User queryUserByUsername(String username);

   //根据用户名和密码查询用户信息(登录页面)
   //返回null说明不存在
   public User queryUserByUsernameAndPassword(String username,String password);

   //保存用户信息（注册页面）
   public int saveUser(User user);
}

UserDaoImpl实现类

public class UserDaoImpl extends BaseDao implements UserDao {
    @Override
    public User queryUserByUsername(String username) {
        String sql = "select `id`,`username`,`password`,`email` from t_user where username=?";
        return queryForOne(User.class,sql,username);
    }

    @Override
    public User queryUserByUsernameAndPassword(String username, String password) {
        String sql = "select `id`,`username`,`password`,`email`,from t_user where username=? and password=?";
        return queryForOne(User.class,sql,username,password);
    }

    @Override
    public int saveUser(User user) {
        String sql = "insert into t_user(`username`,`password`,`email`) values(?,?,?)";
        return update(sql,user.getUsername(),user.getPassword(),user.getEmail());
    }
}

测试类UserDaoTest

快捷键，在UserDao接口中：Ctrl+Shift+t,在test包下面创建测试类

public class UserDaoTest {

    @Test
    public void queryUserByUsername() {
        UserDao userDao = new UserDaoImpl();
        User user = userDao.queryUserByUsername("admin");
        if (user==null){
            System.out.println("用户名不存在");
        }else{
            System.out.println("用户名已存在");
        }
    }

    @Test
    public void queryUserByUsernameAndPassword() {
        UserDao userDao = new UserDaoImpl();
        User user = userDao.queryUserByUsernameAndPassword("admin","123456");
        if (user != null){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }

    @Test
    public void saveUser() {
        UserDao userDao = new UserDaoImpl();
        int result = userDao.saveUser(new User(null,"admin","123456","[email protected]"));
        System.out.println(result);//-1 表示插入失败
    }
}

6 编写UserService

UserService接口

public interface UserService {

    //注册
    public void registUser(User user);

    //登录
    public User login(User user);

    //检查用户名是否存在
    public boolean existsUsername(String username);
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService {

    UserDao userDao = new UserDaoImpl();

    @Override
    public void registUser(User user) {
        userDao.saveUser(user);
    }

    @Override
    public User login(User user) {
        return userDao.queryUserByUsernameAndPassword(user.getUsername(),user.getPassword());
    }

    @Override
    public boolean existsUsername(String username) {
        User user =  userDao.queryUserByUsername(username);
        //user不等于null，说明用户名已经存在，此用户名不可用，返回true
        if (user!=null){
            return true;
        }
        return false;
    }
}

UserServiceTest测试类

在UserService快捷键Ctrl+Shift+t

public class UserServiceTest {

     UserService userService = new UserServiceImpl();

    @Test
    public void registUser() {
        userService.registUser(new User(null,"li","124578","[email protected]"));
        userService.registUser(new User(null,"wang","235689","[email protected]"));
        //已经插入到表中了
    }

    @Test
    public void login() {
        User user = userService.login(new User(null,"li","124578",null));
        System.out.println(user);
        //User{id=4, username='li', password='124578', email='[email protected]'}
    }

    @Test
    public void existsUsername() {
        if (userService.existsUsername("wang")){
            System.out.println("用户名不可用");
        }else{
            System.out.println("用户名可用");
        }
        //用户名不可用
    }

7 实现用户注册功能

在web包下创建RegistServlet类

public class RegistServlet extends HttpServlet {
    
    private UserService userService = new UserServiceImpl();
    
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String username = request.getParameter("username");
        String password = request.getParameter("password");
        String email = request.getParameter("email");
        String code = request.getParameter("code");

        //验证码是否正确
        if ("abcde".equalsIgnoreCase(code)){//现在我们只需要检查验证码是否等于abcde
            //验证码正确时
            //查看用户名是否已经存在
            if (userService.existsUsername(username)){
                //如果已经存在
                System.out.println("用户名" + username +"已经存在");
                //跳转到注册页面
                request.getRequestDispatcher("pages/user/regist.html").forward(request,response);
            }else{
                //用户名不存在
                //保存用户信息到数据库
                userService.registUser(new User(null,username,password,email));
                //调到注册成功页面
                request.getRequestDispatcher("pages/user/regist_success.html").forward(request,response);

            }
        }else{
            //验证码不等于abcde
            System.out.println("验证码"+ code +"错误");
            //跳转到注册页面（请求转发）
            request.getRequestDispatcher("pages/user/regist.html").forward(request,response);
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

配置好web.xml文件

<servlet>
    <servlet-name>RegistServletservlet-name>
    <servlet-class>com.atgw.web.RegistServletservlet-class>
servlet>
<servlet-mapping>
    <servlet-name>RegistServletservlet-name>
    <url-pattern>/registServleturl-pattern>
servlet-mapping>

修改regist.html文件的base标签

同时修改依赖相对路径跳转到路径


<base href="http://localhost:8080/09_book/">

<link type="text/css" rel="stylesheet" href="static/css/style.css" >
<script type="text/javascript" src="static/script/jquery-1.7.2.js">script>

表单的提交方式

<form action="registServlet" method="post">

8 实现用户登录功能

在web包下面创建LoginServlet类

public class LoginServlet extends HttpServlet {

    private UserService userService = new UserServiceImpl();

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //根据用户名和密码查询
        if (userService.login(new User(null,username,password,null))==null){
            //没有查询到
            //登录失败，返回到登录页面
            System.out.println("登录失败");
            request.getRequestDispatcher("pages/user/login.html").forward(request,response);
        }else{
            //查询到了
            //登录成功，跳转到登录成功页面
            request.getRequestDispatcher("pages/user/login_success.html").forward(request,response);
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

web.xml文件

    <servlet>
        <servlet-name>LoginServletservlet-name>
        <servlet-class>com.atgw.web.LoginServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>LoginServletservlet-name>
        <url-pattern>/loginServleturl-pattern>
    servlet-mapping>

base标签

    
   <base href="http://localhost:8080/09_book/">

<link type="text/css" rel="stylesheet" href="static/css/style.css" >

表单提交

<form action="loginServlet" method="post">

第三阶段（优化）

1 所有html页面改为jsp

添加page标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

改文件后缀名为jsp (快捷键：Ctrl+Shift+R)

2 提取共同部分

便于修改和管理

login_success_menu.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

    欢迎大帅哥光临尚硅谷书城
    我的订单
    注销  
    返回

原页面静态引用

			<%-- 静态包含，登陆成功之后的菜单 --%>
			<%@include file="/pages/common/login_success_menu.jsp"%>>

head.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

	<%-- 静态包含 base标签，css文件，jQuery文件 --%>
	<%@include file="/pages/common/head.jsp"%>

footer.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

			
				尚硅谷书城.Copyright ©2015

	<%--静态包含页脚信息--%>
	<%@include file="/pages/common/footer.jsp"%>

manager目录下

manager_menu.jsp


    图书管理
    订单管理
    返回商城

			<%--静态包含 图书相关--%>
			<%@include file="/pages/common/manager_menu.jsp"%>

3 动态的base标签值

head.jsp

<%
    String basePath = request.getScheme()//获取协议
        + "://"
        + request.getServerName()//获取ip地址
        + ":"
        + request.getServerPort()//获取端口号
        + request.getContextPath()//获取工程名
        + "/";
%>

4 表单提交失败的错误回显

登录页面

LoginServlet.java

        if (userService.login(new User(null,username,password,null))==null){
            //没有查询到

            //把错误信息，和回显的表单项信息保存在request域中
            request.setAttribute("msg","用户名或密码错误");
            request.setAttribute("username",username);
            //登录失败，返回到登录页面
            request.getRequestDispatcher("pages/user/login.jsp").forward(request,response);
        }

login.jsp

错误信息

								
									<%=request.getAttribute("msg")==null?"请输入用户名和密码":request.getAttribute("msg")%>

回显信息

									"
									/>

注册页面

RegisterServlet.java

{
            //验证码不等于abcde

            //将错误信息，回显的信息保存在request域中
            request.setAttribute("msg","验证码错误");
            request.setAttribute("username",username);
            request.setAttribute("email",email);

            //跳转到注册页面（请求转发）
            request.getRequestDispatcher("pages/user/regist.jsp").forward(request,response);
        }

if (userService.existsUsername(username)){
                //如果已经存在

                //将错误信息，回显的信息保存在request域中
                request.setAttribute("msg","用户名已存在");
                request.setAttribute("username",username);
                request.setAttribute("email",email);

                //跳转到注册页面
                request.getRequestDispatcher("pages/user/regist.jsp").forward(request,response);
            }

regist.jsp

错误信息

								
									<%=request.getAttribute("msg")==null?"":request.getAttribute("msg")%>

									"
									/>

									"
									/>

5 合并RegistServlet和LoginServlet为UserServlet

1 添加隐藏表单项,并修改from表单的action为”userServlet“

		
									<%-- 隐藏表单 hidden --%>


									<%--隐藏表单项--%>

2 创建UserServlet

public class UserServlet extends HttpServlet {

     private UserService userService = new UserServiceImpl();

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String action = request.getParameter("action");
        //判断是哪个表单提交了
        if ("regist".equals(action)){
            regist(request,response);
        }else if("login".equals(action)){
            login(request,response);
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    //处理注册的业务
    protected void regist(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {

        String username = request.getParameter("username");
        String password = request.getParameter("password");
        String email = request.getParameter("email");
        String code = request.getParameter("code");

        //验证码是否正确
        if ("abcde".equalsIgnoreCase(code)){//现在我们只需要检查验证码是否等于abcde
            //验证码正确时
            //查看用户名是否已经存在
            if (userService.existsUsername(username)){
                //如果已经存在

                //将错误信息，回显的信息保存在request域中
                request.setAttribute("msg","用户名已存在");
                request.setAttribute("username",username);
                request.setAttribute("email",email);

                //跳转到注册页面
                request.getRequestDispatcher("pages/user/regist.jsp").forward(request,response);
            }else{
                //用户名不存在
                //保存用户信息到数据库
                userService.registUser(new User(null,username,password,email));
                //调到注册成功页面
                request.getRequestDispatcher("pages/user/regist_success.jsp").forward(request,response);

            }
        }else{
            //验证码不等于abcde

            //将错误信息，回显的信息保存在request域中
            request.setAttribute("msg","验证码错误");
            request.setAttribute("username",username);
            request.setAttribute("email",email);

            //跳转到注册页面（请求转发）
            request.getRequestDispatcher("pages/user/regist.jsp").forward(request,response);
        }
    }

    //处理登录的业务
    protected void login (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");

        //根据用户名和密码查询
        if (userService.login(new User(null,username,password,null))==null){
            //没有查询到

            //把错误信息，和回显的表单项信息保存在request域中
            request.setAttribute("msg","用户名或密码错误");
            request.setAttribute("username",username);
            //登录失败，返回到登录页面
            request.getRequestDispatcher("pages/user/login.jsp").forward(request,response);
        }else{
            //查询到了
            //登录成功，跳转到登录成功页面
            request.getRequestDispatcher("pages/user/login_success.jsp").forward(request,response);
        }
    }
}

配置web.xml

    <servlet>
        <servlet-name>UserServletservlet-name>
        <servlet-class>com.atgw.web.UserServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>UserServletservlet-name>
        <url-pattern>/userServleturl-pattern>
    servlet-mapping>

6 使用反射优化不同的用户业务

UserServlet

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取隐藏表单项的action的值
        String action = request.getParameter("action");

        //利用反射获取相应的用户行为，避免使用大量的if else
        //我们只需要在下面编写相应的方法即可，修改密码，绑定邮箱，绑定手机号等业务
        try {
            //获取action鉴别对象，获取相应的业务
            Method method = this.getClass().getDeclaredMethod(action,HttpServletRequest.class,HttpServletResponse.class);
            //调用目标业务
            method.invoke(this,request,response );

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

7 抽取BaseServlet

/*
* 因为在用户的业务和图书的业务上都会使用相同的反射方法
* 所以我们可以抽取相同的部分放在 抽象类BaseServlet中
* 使用UserServlet来继承BaseServlet
* */

public abstract class BaseServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取隐藏表单项的action的值
        String action = request.getParameter("action");

        //利用反射获取相应的用户行为，避免使用大量的if else
        //我们只需要在下面编写相应的方法即可，修改密码，绑定邮箱，绑定手机号等业务
        try {
            //获取action鉴别对象，获取相应的业务
            Method method = this.getClass().getDeclaredMethod(action,HttpServletRequest.class,HttpServletResponse.class);
            //调用目标业务
            method.invoke(this,request,response );

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

UserServlet来继承BaseServlet

public class UserServlet extends BaseServlet{
    
}

8 数据的封装和抽取BeanUtils的使用

BeanUtils工具类，它可以一次性的把所有的请求的参数注入JavaBean（对象）中

导包：

commons-beanutils-1.8.0.jar

commons-logging-1.1.1.jar

Utils中的工具类

public class WebUtils {
    public static <T> T copyParamToBean(Map value,T bean){
        try {
            System.out.println("参数注入之前："+bean);
            //把键值对形式Map的value（请求的参数）注入到T(User)中
            BeanUtils.populate(bean,value);
            System.out.println("参数注入之后："+bean);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

第四阶段（EL表达式替换jsp语句）

使用EL表达式替换相应的jsp语句

EL表达式中：requestScope可以获取request域中的数据

regist.jsp页面

	<%=request.getAttribute("msg")==null?"":request.getAttribute("msg")%>

替换成


${ requestScope.msg }

											value="<%=request.getAttribute("username")==null?"":request.getAttribute("username")%>"
										   <%-- EL表达式替换 --%>
								<%--value="${requestScope.username}"--%>

										   value="<%=request.getAttribute("email")==null?"":request.getAttribute("email")%>"
										   <%--value="${requestScope.email}"--%>

login页面

									<%=request.getAttribute("msg")==null?"请输入用户名和密码":request.getAttribute("msg")%>
									<%--使用EL表达式替换--%>
									<%--${ empty requestScope.msg?"请输入用户名和密码":requestScope.msg}--%>

											value="<%=request.getAttribute("username")==null?"":request.getAttribute("username")%>"
										   <%--value="${ requestScope.username}"--%>

第五阶段（图书模块）

MVC概念

Model	View	Controller
模型	视图	控制器

它可以有效指导Web层的代码如何有效分离，单独工作

一种思想，目的是降低耦合，方便后期升级维护

1 图书模块的数据库表

CREATE TABLE t_book(
	`id` INT PRIMARY KEY AUTO_INCREMENT,
	`name` VARCHAR(20),#书名
	`price` DECIMAL(11,2),#价格
	`author` VARCHAR(20),#作者
	`sales` INT,#销量
	`stock` INT,#库存
	`img_path` VARCHAR(200)#图书的图片路径
)

## 插入初始化测试数据
INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'java从入门到放弃' , '国哥' , 80 , 9999 , 9 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '数据结构与算法' , '严敏君' , 78.5 , 6 , 13 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '怎样拐跑别人的媳妇' , '龙伍' , 68, 99999 , 52 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '木虚肉盖饭' , '小胖' , 16, 1000 , 50 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'C++编程思想' , '刚哥' , 45.5 , 14 , 95 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '蛋炒饭' , '周星星' , 9.9, 12 , 53 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '赌神' , '龙伍' , 66.5, 125 , 535 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'Java编程思想' , '阳哥' , 99.5 , 47 , 36 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'JavaScript从入门到精通' , '婷姐' , 9.9 , 85 , 95 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'cocos2d-x游戏编程入门' , '国哥' , 49, 52 , 62 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'C语言程序设计' , '谭浩强' , 28 , 52 , 74 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'Lua语言程序设计' , '雷丰阳' , 51.5 , 48 , 82 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '西游记' , '罗贯中' , 12, 19 , 9999 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '水浒传' , '华仔' , 33.05 , 22 , 88 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '操作系统原理' , '刘优' , 133.05 , 122 , 188 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '数据结构 java版' , '封大神' , 173.15 , 21 , 81 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'UNIX高级环境编程' , '乐天' , 99.15 , 210 , 810 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , 'javaScript高级编程' , '国哥' , 69.15 , 210 , 810 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '大话设计模式' , '国哥' , 89.15 , 20 , 10 , 'static/img/default.jpg');

INSERT INTO t_book(`id` , `name` , `author` , `price` , `sales` , `stock` , `img_path`)
VALUES(NULL , '人月神话' , '刚哥' , 88.15 , 20 , 80 , 'static/img/default.jpg');


## 查看表内容
SELECT id,NAME,author,price,sales,stock,img_path FROM t_book;

2 JavaBean对象

public class Book {

    private Integer id;
    private String name;
    private String author;
    private BigDecimal price;
    private Integer sales;
    private Integer stock;
    private String imgPath = "static/img/default.jpg";

    public Book() {
    }

    public Book(Integer id, String name, String author, BigDecimal price, Integer sales, Integer stock, String imgPath) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.price = price;
        this.sales = sales;
        this.stock = stock;
                //要求传入的imgPath不能为空
        if (this.imgPath != null && !"".equals(this.imgPath)){
            this.imgPath = imgPath;
        }
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public Integer getSales() {
        return sales;
    }

    public void setSales(Integer sales) {
        this.sales = sales;
    }

    public Integer getStock() {
        return stock;
    }

    public void setStock(Integer stock) {
        this.stock = stock;
    }

    public String getImgPath() {
        return imgPath;
    }

    public void setImgPath(String imgPath) {
                //要求传入的imgPath不能为空

        if (this.imgPath != null && !"".equals(this.imgPath)){
            this.imgPath = imgPath;
        }
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", sales=" + sales +
                ", stock=" + stock +
                ", imgPath='" + imgPath + '\'' +
                '}';
    }
}

3 Dao和测试Dao

BookDao接口

public interface BookDao {
    //增加
    public int addBook(Book book);

    //删除
    public int deleteBookById(Integer id);

    //修改
    public int updateBook(Book book);

    //根据id查询图书
    public Book queryBookById(Integer id);

    //查询所有图书
    public List<Book> queryBooks();
}

BookDaoImpl实现类

public class BookDaoImpl extends BaseDao implements BookDao {
    @Override
    public int addBook(Book book) {
        String sql = "insert into t_book(`name`,`author`,`price`,`sales`,`stock`,`img_path`)values(?,?,?,?,?,?)";
        return update(sql,book.getName(),book.getAuthor(),book.getPrice(),book.getSales(),book.getStock(),book.getImgPath());
    }

    @Override
    public int deleteBookById(Integer id) {
        String sql = "delete from t_book where id=?";
        return update(sql,id);
    }

    @Override
    public int updateBook(Book book) {
        String sql = "update t_book set `name`=?,`author`=?,`price`=?,`sales`=?,`stock`=?,`img_path`=? where id=?";
        return update(sql,book.getName(),book.getAuthor(),book.getPrice(),book.getSales(),book.getStock(),book.getImgPath(),book.getId());
    }

    @Override
    public Book queryBookById(Integer id) {
        String sql = "select `id`,`name`,`author`,`price`,`sales`,`stock`,`img_path`as imgPath from t_book where id=?";
        return queryForOne(Book.class,sql,id);
    }

    @Override
    public List<Book> queryBooks() {
        String sql = "select `id`,`name`,`author`,`price`,`sales`,`stock`,`img_path`as imgPath from t_book";
        return queryForList(Book.class,sql);
    }
}

BookDaoTest测试类（在BookDao接口中使用快捷键Ctrl+Shift+T）

public class BookDaoTest {

     private BookDao bookDao = new BookDaoImpl();

    @Test
    public void addBook() {
        bookDao.addBook(new Book(null,"这个世界好奇怪","詹三",new BigDecimal(99),987567,66,null));
    }

    @Test
    public void deleteBookById() {
        bookDao.deleteBookById(21);
    }

    @Test
    public void updateBook() {
        bookDao.updateBook(new Book(22,"这个世界真好","詹三",new BigDecimal(99),9867,66,null));
    }

    @Test
    public void queryBookById() {
        System.out.println(bookDao.queryBookById(13));
    }

    @Test
    public void queryBooks() {
        for (Book book : bookDao.queryBooks()){
            System.out.println(book);
        }
    }
}

4 Service和测试Service

BookService接口

public interface BookService {

    //增加图书
    public void addBook(Book book);

    //删除图书
    public void deleteBookById(Integer id);

    //修改图书
    public void updateBook(Book book);

    //查询图书
    public Book QueryBookById(Integer id);

    //查询所有图书
    public List<Book> queryBooks();
}

BookServiceImpl实现类

public class BookServiceImpl implements BookService {

    private BookDao bookDao = new BookDaoImpl();

    @Override
    public void addBook(Book book) {
        bookDao.addBook(book);
    }

    @Override
    public void deleteBookById(Integer id) {
        bookDao.deleteBookById(id);
    }

    @Override
    public void updateBook(Book book) {
        bookDao.updateBook(book);
    }

    @Override
    public Book QueryBookById(Integer id) {
        return bookDao.queryBookById(id);
    }

    @Override
    public List<Book> queryBooks() {
        return bookDao.queryBooks();
    }
}

BookServiceTest测试类

public class BookServiceTest {

     private BookService bookService = new BookServiceImpl();

    @Test
    public void addBook() {
        bookService.addBook(new Book(null,"这个世界好奇怪","詹三",new BigDecimal(99),987567,66,null));
    }

    @Test
    public void deleteBookById() {
        bookService.deleteBookById(23);
    }

    @Test
    public void updateBook() {
        bookService.updateBook(new Book(23,"这个世界真好","詹三",new BigDecimal(99),9567,66,null));
    }

    @Test
    public void queryBookById() {
        System.out.println(bookService.QueryBookById(18));
    }

    @Test
    public void queryBooks() {
        for (Book book: bookService.queryBooks()){
            System.out.println(book);
        }
    }
}

5 Web层和页面联调测试

BookServlet类

图书列表

public class BookServlet extends BaseServlet {

    private BookService bookService = new BookServiceImpl();

     //增加图书
    protected void add(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    //删除图书
    protected void delete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    //修改图书
    protected void update(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }

    //列表查询所有图书
    protected void list(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //1.通过bookService查询全部图书
        List<Book> books = bookService.queryBooks();
        //2.设置域对象
        request.setAttribute("books",books);
        //3.请求转发到 /pages/manager/book_manager.jsp页面
        request.getRequestDispatcher("/pages/manager/book_manager.jsp").forward(request,response);
    }
}

web.xml

    <servlet>
        <servlet-name>BookServletservlet-name>
        <servlet-class>com.atgw.web.BookServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>BookServletservlet-name>
                
        <url-pattern>/manager/bookServleturl-pattern>
    servlet-mapping>

修改manager_menu页面的图书管理地址

 <%-- /manager/bookServlet 是Servlet访问地址，action=list是调用服务器（BookServlet）中的list方法，查询全部图书--%>
    图书管理

在book_manager页面对遍历所有图书

			<%--利用JSTL对所有的图书进行遍历--%>
			
				
					${book.name}
					${book.price}
					${book.author}
					${book.sales}
					${book.stock}
					修改
					删除

实现DoGet方法（因为图书管理板块的提交方式是Get请求，所以我们让doGet执行doPost相同的操作）

BaseServlet

public abstract class BaseServlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取隐藏表单项的action的值
        String action = request.getParameter("action");

        //利用反射获取相应的用户行为，避免使用大量的if else
        //我们只需要在下面编写相应的方法即可，修改密码，绑定邮箱，绑定手机号等业务
        try {
            //获取action鉴别对象，获取相应的业务
            Method method = this.getClass().getDeclaredMethod(action,HttpServletRequest.class,HttpServletResponse.class);
            //调用目标业务
            method.invoke(this,request,response );

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //因为图书管理板块的提交方式是Get请求，所以我们让doGet执行doPost相同的操作
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request,response);
    }
}

前台和后台

前台

普通用户使用

一般不需要权限检查，就可以访问的资源（比如淘宝不进行登录就可以访问的首页）

地址：/client/bookServlet

后台

管理员使用

一般都需要权限检查

地址：/manager/bookServlet

添加图书

book_edit.jsp页面（对表单的提交行为和方式设置，设置隐藏表单项）

隐藏域是用来收集或发送信息的不可见元素，对于网页的访问者来说，隐藏域是看不见的。当表单被提交时，隐藏域就会将信息用你设置时定义的名称和值发送到服务器上

		
			<%--修改表单的提交行为 跳转到book_manager.jsp页面,提交方式get和post都可以--%>
			
				<%--隐藏表单域，告诉服务器要执行的方法是add --%>
				
				
					
						名称
						价格
						作者
						销量
						库存
						操作

BookServlet中的add方法

     //增加图书
    protected void add(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //把添加的图书封装成一个图书对象
        Book book = WebUtils.copyParamToBean(request.getParameterMap(),new Book());
        //保存图书到数据库
        bookService.addBook(book);
        //跳转到图书列表页面
        //调用list方法是要再一次刷新图书信息

        /*但是如果用请求转发的话，会有bug,如果用户按下功能键F5，则浏览器会发起记录中最后一次请求，造成表单重复提交*/
        //request.getRequestDispatcher("/manager/bookServlet?action=list").forward(request,response);
        //使用重定向
        //它的地址是从端口号开始，所以要先获取工程路径request.getContextPath()
        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=list");
    }

删除图书

book_manager页面的删除a标签

点击后执行的方法delete，并且返回id参数

					删除

添加点击删除提示框

BookServlet中的delete方法

将字符串转化成int封装成一个工具类（在WebUtils中）

    //将字符串转化成int类型
    public static int parseInt(String s,int defaultValue){
        try {
            return Integer.parseInt(s);
        }catch (Exception e){
            e.printStackTrace();
        }
        return defaultValue;
    }

    //删除图书
    protected void delete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取参数id
        int id = WebUtils.parseInt(request.getParameter("id"), 0);
        //删除图书
        bookService.deleteBookById(id);
        //重定向跳转图书管理页面
        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=list");
    }

修改图书

1.数据回显

book_manager.jsp（点击修改执行的动作，getBook()方法查询图书，并返回id）
					修改
book_edit.jsp页面（动态获取当前的修改对象图书的信息）
   
   
   
   
   
   

2.保存修改并显示

因为book_edit同时实现添加图书和修改图书两种功能，所以我们需要判断是哪种行为，从而执行不同的方法

book_edit.jsp的隐藏表单域

		<%--隐藏表单域，告诉服务器要执行的方法时add --%>
				
					<%--${empty param.id?"add":"update"} 是判断页面的当前行为，因为添加不需要id属性，而修改需要id属性--%>

用隐藏域来获取id

修改方法update

    //修改图书
    protected void update(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求的参数，封装成BOOk对象
        Book book = WebUtils.copyParamToBean(request.getParameterMap(), new Book());
        //修改图书
        bookService.updateBook(book);
        //重定向到图书管理列表
        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=list");
    }

后台分页

Page类

public class Page<T> {

    //静态常量，页面显示数据数目
    public static final Integer PAGE_SIZE = 4;

    //当前页码
    private Integer pageNo;

    //总页码
    private Integer pageTotal;

    //当前页显示数量
    private Integer pageSize = PAGE_SIZE;

    //总记录数
    private Integer pageTotalCount;

    //当前页数据
    private List<T> items;

    public static Integer getPageSize() {
        return PAGE_SIZE;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public Integer getPageTotalCount() {
        return pageTotalCount;
    }

    public void setPageTotalCount(Integer pageTotalCount) {
        this.pageTotalCount = pageTotalCount;
    }

    public List<T> getItems() {
        return items;
    }

    public void setItems(List<T> items) {
        this.items = items;
    }

    public Integer getPageNo() {
        return pageNo;
    }

    public void setPageNo(Integer pageNo) {
        this.pageNo = pageNo;
    }

    public Integer getPageTotal() {
        return pageTotal;
    }

    public void setPageTotal(Integer pageTotal) {
        this.pageTotal = pageTotal;
    }

    @Override
    public String toString() {
        return "Page{" +
                "pageNo=" + pageNo +
                ", pageTotal=" + pageTotal +
                ", pageSize=" + pageSize +
                ", pageTotalCount=" + pageTotalCount +
                ", items=" + items +
                '}';
    }

    public Page() {
    }

    public Page(Integer pageNo, Integer pageTotal, Integer pageSize, Integer pageTotalCount, List<T> items) {
        this.pageNo = pageNo;
        this.pageTotal = pageTotal;
        this.pageSize = pageSize;
        this.pageTotalCount = pageTotalCount;
        this.items = items;
    }
}

BookDao接口

    Integer queryForPageTotalCount();

    List<Book> quertForItems(int begin, int pageSize);

BookDaoImpl实现类（queryForPageTotalCount()方法，quertForItems(int begin, int pageSize)方法）

    @Override
    public Integer queryForPageTotalCount() {
        String sql = "select count(*) from t_book";
        Number count = (Number)queryForSingleValue(sql);
        //queryForSingleValue()返回值是Object类型，不能直接强制转化为Integer
        return count.intValue();//转成Integer类
    }

    @Override
    public List<Book> quertForItems(int begin, int pageSize) {
        String sql = "select `id`,`name`,`author`,`price`,`sales`,`stock`,`img_path`as imgPath from t_book limit ?,?";
        List<Book> books = queryForList(Book.class, sql, begin, pageSize);
        return books;
    }

BookDaoTest测试类

    @Test
    public void queryForPageTotalCount(){
        System.out.println(bookDao.queryForPageTotalCount());
    }
    @Test
    public void quertForItems(){
        for( Book book:bookDao.quertForItems(0,4)){
            System.out.println(book);
        }
    }

BookService接口

 Page<Book> page(int pageNo, int pageSize);

BookServiceImpl实现类（page()方法）

 @Override
 public Page<Book> page(int pageNo, int pageSize) {
     Page page = new Page();
     //设置当前页
     page.setPageNo(pageNo);
     //设置每页显示数量
     page.setPageSize(pageSize);

     //获取（使用Dao层的sql语句获取）并设置总记录数
     Integer pageTotalCount = bookDao.queryForPageTotalCount();
     page.setPageTotalCount(pageTotalCount);

     //获取并设置总页码数
     int pageTotal = pageTotalCount / pageSize;
     if (pageTotalCount % pageSize!=0){//除不尽时，总页码加1
         pageTotal+=1;
     }
     page.setPageTotal(pageTotal);

     //设置当前页面显示数据
     int begin = (page.getPageNo() - 1)*pageSize;//当前页数据的开始索引
     List<Book> books = bookDao.quertForItems(begin,pageSize);
     page.setItems(books);

     return page;
 }

BookService测试（page方法）

    @Test
    public void page(){
        System.out.println(bookService.page(2,4));
    }

BookServlet（page()方法）

    //分页
    protected void page(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
        //1 获取当前页码,默认值为1
        int pageNo = WebUtils.parseInt(request.getParameter("pageNo"), 1);
        //1 获取每页显示数据数目，默认值为PAGE_SIZE
        int pageSize = WebUtils.parseInt(request.getParameter("pageSize"), Page.PAGE_SIZE);
        //2 获取Page对象
        Page<Book> page = bookService.page(pageNo, pageSize);
        //3 保存到域对象
        request.setAttribute("page",page);
        //4 请求转发到book_manager页面
        request.getRequestDispatcher("/pages/manager/book_manager.jsp").forward(request,response);
    }

manager_menu.jsp

跳转的行为（由list–>page;全部遍历–>分页遍历）
        图书管理

book_manager.jsp

全部图书遍历修改为分页信息遍历
添加页脚信息（动态）

			<%--分页后，只对page对象的items(当前页面数据)进行遍历--%>

并在最后加上页脚信息

		
			首页
			上一页
			${requestScope.page.pageNo-1}
			【${requestScope.page.pageNo}】
			${requestScope.page.pageNo+1}
			下一页
			末页
			共${requestScope.page.pageTotal}页，${requestScope.page.pageTotalCount}条记录 到第页

首页，上一页，末页，下一页(book_manager.jsp)

			<%--如果当前页大于第1页，才显示首页，上一页--%>
			
				首页
				上一页
			

			
				<%--如果当前页小于总页数，才显示末页，下一页--%>
			
				下一页
				末页

跳转到指定页面（绑定单击响应事件）

到第页

在head.jsp中设置

 pageContext.setAttribute("basePath",basePath);

如果在地址栏中直接改变页数，则我们需要设置数据边界有效性检查（在每次改变地址时都会检查）

    public void setPageNo(Integer pageNo) {
        //数据边界的有效性检查
        if (pageNo < 1){
            pageNo=1;
        }
        if (pageNo > pageTotal){
            pageNo = pageTotal;
        }
        this.pageNo = pageNo;
    }

分页点击跳转

                <%--页码点击跳转--%>
            
                <%--情况1：总页数小于等于5时--%>
                
                    
                        <%--如果是当前页，则不可点击，不可跳转--%>
                        
                            【${i}】
                        
                        <%--如果是其他页，则可以点击，可以跳转--%>
                        
                            ${i}
                        
                    
                

                <%--情况2：总页数大于5时 --%>
                
                    <%--情况2.1 当前页是前3页 --%>
                    
                        
                            
                                <%--如果是当前页，则不可点击，不可跳转--%>
                                
                                    【${i}】
                                
                                <%--如果是其他页，则可以点击，可以跳转--%>
                                
                                    ${i}
                                
                            
                        

                        <%--情况2.2 当前页是后3页 --%>
                        
                            
                                <%--如果是当前页，则不可点击，不可跳转--%>
                                
                                    【${i}】
                                
                                <%--如果是其他页，则可以点击，可以跳转--%>
                                
                                    ${i}
                                
                            
                        

                        <%--情况2.3 当前页是中间页 --%>
                        
                            
                                <%--如果是当前页，则不可点击，不可跳转--%>
                                
                                    【${i}】
                                
                                <%--如果是其他页，则可以点击，可以跳转--%>
                                
                                    ${i}

修改分页对添加，修改，删除图书的影响

BookServlet中的方法请求转发和重定向语句所有的list改为page

1 添加图书（添加之后要看到最后一页添加的结果）
				添加图书
add()方法（因为在边界有效性上做了处理，大于总页数的会显示最后一页的内容，所以给当前最后一页永远加1时会一直显示最后一页）
        //分页之后，要看到刚才添加的图书信息，所以要跳转到最后一页
        int pageNo = WebUtils.parseInt(request.getParameter("pageNo"),0);
        pageNo+=1;

        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=page&pageNo="+pageNo);
2 删除图书
					删除
delete()方法
        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=page&pageNo="+request.getParameter("pageNo"));
3 修改图书
					修改
        response.sendRedirect(request.getContextPath()+"/manager/bookServlet?action=page&pageNo="+request.getParameter("pageNo"));

前台分页

从web目录下的index.jsp请求转发到client目录下的index.jsp（间接访问）

ClientBookServlet

public class ClientBookServlet extends BaseServlet {

     private BookService bookService = new BookServiceImpl();

     //分页
    protected void page(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
        //1 获取当前页码,默认值为1
        int pageNo = WebUtils.parseInt(request.getParameter("pageNo"), 1);
        //1 获取每页显示数据数目，默认值为PAGE_SIZE
        int pageSize = WebUtils.parseInt(request.getParameter("pageSize"), Page.PAGE_SIZE);
        //2 获取Page对象
        Page<Book> page = bookService.page(pageNo, pageSize);
        //3 保存到域对象
        request.setAttribute("page",page);
        //4 请求转发到book_manager页面
        request.getRequestDispatcher("/pages/client/index.jsp").forward(request,response);
    }
}

web.xml

    <servlet>
        <servlet-name>ClientBookServletservlet-name>
        <servlet-class>com.atgw.web.ClientBookServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>ClientBookServletservlet-name>
        <url-pattern>/client/bookServleturl-pattern>
    servlet-mapping>

Web目录下的index.jsp

只负责请求转发，并执行page()方法
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%--只负责请求转发，并执行page方法--%>

client目录下的index.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>




书城首页
	<%-- 静态包含 base标签，css文件，jQuery文件 --%>
	<%@include file="/pages/common/head.jsp"%>

	

	


	
	
			
			网上书城
			
				登录 |
				注册   
				购物车
				后台管理
			
	
	
		
			
				
					价格： 元 - 
						 元 
						
				
			
			
				您的购物车中有3件商品
				
					您刚刚将时间简史加入到了购物车中
				
			

			
				
					
						
					
					
						
							书名:
							${book.name}
						
						
							作者:
							${book.author}
						
						
							价格:
							${book.price}
						
						
							销量:
							${book.sales}
						
						
							库存:
							${book.stock}
						
						
							
						
					
				
			


		

		
			<%--如果当前页大于第1页，才显示首页，上一页--%>
			
				首页
				上一页
			

			<%--页码点击跳转--%>
			
				<%--情况1：总页数小于等于5时--%>
				
					
						<%--如果是当前页，则不可点击，不可跳转--%>
						
							【${i}】
						
						<%--如果是其他页，则可以点击，可以跳转--%>
						
							${i}
						
					
				

				<%--情况2：总页数大于5时 --%>
				
					<%--情况2.1 当前页是前3页 --%>
					
						
							
								<%--如果是当前页，则不可点击，不可跳转--%>
								
									【${i}】
								
								<%--如果是其他页，则可以点击，可以跳转--%>
								
									${i}
								
							
						

						<%--情况2.2 当前页是后3页 --%>
						
							
								<%--如果是当前页，则不可点击，不可跳转--%>
								
									【${i}】
								
								<%--如果是其他页，则可以点击，可以跳转--%>
								
									${i}
								
							
						

						<%--情况2.3 当前页是中间页 --%>
						
							
								<%--如果是当前页，则不可点击，不可跳转--%>
								
									【${i}】
								
								<%--如果是其他页，则可以点击，可以跳转--%>
								
									${i}
								
							
						
					
				
			


			<%--如果当前页小于总页数，才显示末页，下一页--%>
			
				下一页
				末页
			

			共${requestScope.page.pageTotal}页，${requestScope.page.pageTotalCount}条记录 到第页
			

		
	
	
	
	
		
			尚硅谷书城.Copyright ©2015

前后台分页条的抽取

Page类中新添加一个url属性（分页条的地址）

Private String url

1 替换为url

将前台（client目录下的index.jsp）分页条代码块中的client/bookServlet?action=page替换成${ requestScope.page.url}
将后台（book_manager.jsp）分页条代码块中的manager/bookServlet?action=page替换成${ requestScope.page.url}

2 设置page对象的url

前台 ClientBookServlet中的page()方法

        //设置请求地址
        page.setUrl("client/bookServlet?action=page");

后台BookServlet中的page()方法

        //设置请求地址
        page.setUrl("manager/bookServlet?action=page");

3 最后从client/index.jsp和book_manager.jsp中抽取分页的代码块到common/page_nav.jsp中，并在原两个页面中静态引用

page_nav.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%--分页条--%>

    <%--如果当前页大于第1页，才显示首页，上一页--%>
    
        首页
        上一页
    

    <%--页码点击跳转--%>
    
        <%--情况1：总页数小于等于5时--%>
        
            
                <%--如果是当前页，则不可点击，不可跳转--%>
                
                    【${i}】
                
                <%--如果是其他页，则可以点击，可以跳转--%>
                
                    ${i}
                
            
        

        <%--情况2：总页数大于5时 --%>
        
            <%--情况2.1 当前页是前3页 --%>
            
                
                    
                        <%--如果是当前页，则不可点击，不可跳转--%>
                        
                            【${i}】
                        
                        <%--如果是其他页，则可以点击，可以跳转--%>
                        
                            ${i}
                        
                    
                

                <%--情况2.2 当前页是后3页 --%>
                
                    
                        <%--如果是当前页，则不可点击，不可跳转--%>
                        
                            【${i}】
                        
                        <%--如果是其他页，则可以点击，可以跳转--%>
                        
                            ${i}
                        
                    
                

                <%--情况2.3 当前页是中间页 --%>
                
                    
                        <%--如果是当前页，则不可点击，不可跳转--%>
                        
                            【${i}】
                        
                        <%--如果是其他页，则可以点击，可以跳转--%>
                        
                            ${i}
                        
                    
                
            
        
    


    <%--如果当前页小于总页数，才显示末页，下一页--%>
    
        下一页
        末页
    

    共${requestScope.page.pageTotal}页，${requestScope.page.pageTotalCount}条记录 到第页

client/index.jsp和book_manager.jsp

        <%--静态包含分页条--%>
		<%@include file="../common/page_nav.jsp"%>

根据价格区间分页

BookDao接口

    List<Book> queryForItemsByPrice(int begin, int pageSize, int min, int max);

    Integer queryForPageTotalCountByPrice(int min, int max);

BookDaoImpl实现类


    @Override
    public Integer queryForPageTotalCountByPrice(int min, int max) {
        String sql = "select count(*) from t_book where price between ? and ?";
        Number count = (Number)queryForSingleValue(sql,min,max);
        //queryForSingleValue()返回值是Object类型，不能直接强制转化为Integer
        return count.intValue();//转成Integer类
    }

    @Override
    public List<Book> queryForItemsByPrice(int begin, int pageSize, int min, int max) {
        String sql = "select `id`,`name`,`author`,`price`,`sales`,`stock`,`img_path`as imgPath from t_book " +
                "where price between ? and ? order by `price` ASC limit ?,?";
        List<Book> books = queryForList(Book.class, sql, min, max, begin, pageSize);
        return books;
    }

BookDao测试

   @Test
    public void queryForPageTotalCountByPrice(){
        System.out.println(bookDao.queryForPageTotalCountByPrice(20,100));
    }

    @Test
    public void queryForItemsByPrice(){
        for( Book book:bookDao.queryForItemsByPrice(0,4,20,100)){
            System.out.println(book);
        }
    }

BookService接口

//根据价区间查询
    Page<Book> pageByPrice(int pageNo, int pageSize, int min, int max);

BookServiceImpl实现类

   @Override
    public Page<Book> pageByPrice(int pageNo, int pageSize, int min, int max) {
        Page page = new Page();

        //设置每页显示数量
        page.setPageSize(pageSize);

        //获取（使用Dao层的sql语句获取）并设置总记录数
        Integer pageTotalCount = bookDao.queryForPageTotalCountByPrice(min,max);
        page.setPageTotalCount(pageTotalCount);

        //获取并设置总页码数
        int pageTotal = pageTotalCount / pageSize;
        if (pageTotalCount % pageSize!=0){//除不尽时，总页码加1
            pageTotal+=1;
        }
        page.setPageTotal(pageTotal);

        //设置当前页
        page.setPageNo(pageNo);

        //设置当前页面显示数据
        int begin = (page.getPageNo() - 1)*pageSize;//当前页数据的开始索引
        List<Book> books = bookDao.queryForItemsByPrice(begin,pageSize,min,max);
        page.setItems(books);

        return page;
    }

BookService测试

    @Test
    public void pageByPrice(){
        System.out.println(bookService.pageByPrice(0,4,20,100));
    }

ClientBookServlet

    //价格区间搜索分页
    protected void pageByPrice(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
        //1 获取当前页码,默认值为1
        int pageNo = WebUtils.parseInt(request.getParameter("pageNo"), 1);
        //1 获取每页显示数据数目，默认值为PAGE_SIZE
        int pageSize = WebUtils.parseInt(request.getParameter("pageSize"), Page.PAGE_SIZE);

        //获取价格区间
        int min = WebUtils.parseInt(request.getParameter("min"),0);
        int max = WebUtils.parseInt(request.getParameter("max"),Integer.MAX_VALUE);


        //2 获取Page对象
        Page<Book> page = bookService.pageByPrice(pageNo, pageSize,min,max);

        //设置请求地址
        page.setUrl("client/bookServlet?action=pageByPrice");

        //3 保存到域对象
        request.setAttribute("page",page);
        //4 请求转发到book_manager页面
        request.getRequestDispatcher("/pages/client/index.jsp").forward(request,response);
    }

区间参数回显（${param.min} ${param.max}）
 元 -
						 元

解决bug

当我们点击分页行跳转时，地址栏中不会带有区间的min和max,造成价格区间所搜索的记录不会显示，以我们添加上去

在BookServlet程序pageByPrice()中

        /*解决bug*/
        //当我们点击分页行跳转时，地址栏中不会带有区间的min和max,造成价格区间所搜索的记录不会显示，以我们添加上去
        StringBuilder sb = new StringBuilder("client/bookServlet?action=pageByPrice");
        //获取地址栏中的min,max参数
        //如果有最小价格参数，就追加到地址栏中
        if (request.getParameter("min")!=null){
            sb.append("&min=").append(request.getParameter("min"));
        }
        //如果有最大价格参数，就追加到地址栏中
        if (request.getParameter("max")!=null){
            sb.append("&max=").append(request.getParameter("max"));
        }

        //设置请求地址
        page.setUrl(sb.toString());

第六阶段

1 显示登录用户的信息

因为在用户登录成功之后，在前台所有的页面上都要显示用户的用户名信息，所以我们用Session域保存数据

UserSetvlet的login()方法

//保存用户登陆成功之后的信息到Session域中
         request.getSession().setAttribute("user",loginUser);

login_success_menu.jsp中改变欢迎信息,并修改其他页的地址
    欢迎${sessionScope.user.username}光临尚硅谷书城

    我的订单
    注销  
    返回

当用户登录成功之后，登录和注册按钮就不用显示了（client/index.jsp）

<%--如果用户还没有登录，显示登录和注册的菜单--%>
               
                   登录 |
                   注册   
               
                <%--如果登录成功，显示欢迎用户的信息--%>
               
                   欢迎${sessionScope.user.username}光临尚硅谷书城
                   我的订单
                   注销

2 注销用户

销毁Session中用户的信息
重定向到首页

UserServlet程序

   //注销
   protected void logout(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //销毁Session对象
       request.getSession().invalidate();
       //重定向到首页
       response.sendRedirect(request.getContextPath()+"/");//工程路径下默认就是首页
   }

client/index.jsp

                   注销

login_success_menu.jsp

   注销

3 表单重复提交—验证码

三种情况

提交完表单，服务器使用请求转发来进行页面跳转，如果用户按下F5刷新功能键，就会发起最后一次请求，造成表单的重复提交，解决方法：使用重定向来进行转发
用户正常提交服务器，但是由于网络延迟等原因，迟迟未收到服务器的响应，这个时候，用户以为提交失败就重复点击提交按钮，就会造成表单的重复提交
用户正常提交服务器，服务器也没有延迟，但是提交完成之后，用户回退浏览器，重新提交，也会造成表单重复提交

4 谷歌验证码kaptcha的使用

导入kaptcha-2.3.2.jar

在web.xml中去配置用于验证码生成的Servlet程序（KaptchaServlet）

在表单中使用img标签使用它

在服务器获取谷歌生成验证码和客户端发送过来的验证码比较使用

UserServlet程序(在注册方法中进行判断)

//获取Session中的验证码
       String token = (String) request.getSession().getAttribute(KAPTCHA_SESSION_KEY);
       //获取之后直接删除Session中的验证码，防止重复提交表单
       request.getSession().removeAttribute(KAPTCHA_SESSION_KEY);


//验证码是否正确
       if (token!=null && token.equalsIgnoreCase(code))

web.xml

   <servlet>
       <servlet-name>KaptchaServletservlet-name>
       <servlet-class>com.google.code.kaptcha.servlet.KaptchaServletservlet-class>
   servlet>
   <servlet-mapping>
       <servlet-name>KaptchaServletservlet-name>
       <url-pattern>/kaptcha.jpgurl-pattern>
   servlet-mapping>

注册页面regist.jsp

验证码：

点击验证码进行切换(就是给验证码图片加上点击事件)

因为浏览器的缓存原因，我们每次都要将请求地址的值变得不同，所以加上一个时间戳

5 购物车模块

购物车商品对象 CartItem类

public class CartItem {
    private Integer id;
    private String name;
    private Integer count;
    private BigDecimal price;
    private BigDecimal totalPrice;
}

购物车对象 Cart类

public class Cart {
   //实际上用不到总价格和总数量的全局变量，这两个变量我们是通过对所有的商品项遍历而得的
//private Integer totalCount;
  // private BigDecimal totalPrice;
   //private List items = new ArrayList();
   
   
   //我们想一种商品只是一个商品项，所以用Map数据结构（不重复）来存储商品项对象，id-->商品对象
   private Map<Integer,CartItem> items = new LinkedHashMap<>();
}

Cart类的四个方法的实现

    //增加商品项
    public void addItem(CartItem cartItem){
        //在购物车的商品项中查找是否已经存在了要插入的商品
        CartItem item = items.get(cartItem.getId());

        if (item == null) {
            //没有存在，则插入
            items.put(cartItem.getId(),cartItem);
        }else{
            //已经存在，则修改商品总数量和总价格
            item.setCount(item.getCount()+1);
            item.setTotalPrice(item.getPrice().multiply(new BigDecimal(item.getCount())));
        }
    }

    //删除商品项
    public void deleteItem(Integer id){
        items.remove(id);
    }

    //清空购物车
    public void clear(){
        items.clear();
    }

    //修改商品数量
    public void updateCount(Integer id,Integer count){
        //先查看购物车中是否有此商品
        CartItem item = items.get(id);
        if (item !=null){
            item.setCount(count);
            //修改商品总价格
            item.setTotalPrice(item.getPrice().multiply(new BigDecimal(item.getCount())));
        }
    }

    public Integer getTotalCount() {
        Integer totalCount = 0;
        //遍历每个商品项的数量累加
        for (Map.Entry<Integer,CartItem> entry : items.entrySet()){
            totalCount += entry.getValue().getCount();
        }
        return  totalCount;
    }

    public BigDecimal getTotalPrice() {
        BigDecimal totalPrice = new BigDecimal(0);
        //遍历每个商品项的总金额累加
        for (Map.Entry<Integer,CartItem> entry : items.entrySet()){
            totalPrice = totalPrice.add(entry.getValue().getTotalPrice());
        }
        return totalPrice;
    }

    public Map<Integer, CartItem> getItems() {
        return items;
    }

    public void setItems(Map<Integer, CartItem> items) {
        this.items = items;
    }

    @Override
    public String toString() {
        return "Cart{" +
                "totalCount=" + getTotalCount() +
                ", totalPrice=" + getTotalPrice() +
                ", items=" + items +
                '}';
    }
}

6 添加商品到购物车

理解

因为在添加购物车时，购物车只有一个，我们把它放在Session中，刚开始添加购物车时，先判断Session中是否有购物车，如果没有，则新创建一个存放在Session域中
因为在添加完购物车之后，服务器处理了添加操作，我们还要把页面返回到刚才用户浏览的页面
在HTTP协议中有一个请求头，叫Referer,它可以把请求发起时，浏览器地址栏中的地址发送给服务器

CartServlet（addItem方法）

//添加购物车
    protected void addItem(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        //1 获取请求的参数，商品编号
        int id = WebUtils.parseInt(request.getParameter("id"),0);
        //2 调用bookServlet.queryBookById() 查询获取到图书的信息
        Book book = bookService.QueryBookById(id);
        //3 把图书信息，转换成CartItem商品项
        CartItem item = new CartItem(book.getId(), book.getName(), 1, book.getPrice(), book.getPrice());
        //4 调用Cart.addItem(CartItem) 添加商品项
        /*因为在添加购物车时，购物车只有一个，我们把它放在Session中
        * 刚开始添加购物车时，先判断Session中是否有购物车，如果没有，
        * 则新创建一个存放在Session域中 */
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        if (cart == null){
            cart = new Cart();
            request.getSession().setAttribute("cart",cart);
        }
        cart.addItem(item);
        //5 重定向回商品列表页面
        //因为在添加完购物车之后，服务器处理了添加操作，我们还要把页面返回到刚才用户浏览的页面
        /*在HTTP协议中有一个请求头，叫Referer,它可以把请求发起时，浏览器地址栏中的地址发送给服务器*/
        response.sendRedirect(request.getHeader("Referer"));
    }

web.xml

    <servlet>
        <servlet-name>CartServletservlet-name>
        <servlet-class>com.atgw.web.CartServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>CartServletservlet-name>
        <url-pattern>/cartServleturl-pattern>
    servlet-mapping>

client/index.jsp

<%--自定义属性bookId,获取点击的商品的id--%>

7 购物车的展示

遍历购物车 cart.jsp

			<%--遍历购物车--%>
			
				
					${entry.value.name}
					${entry.value.count}
					${entry.value.price}
					${entry.value.totalPrice}
					删除

购物车非空和空的情况

<%--购物车非空，输出下面的信息--%>
		
			
				购物车中共有${sessionScope.cart.totalCount}件商品
				总金额${sessionScope.cart.totalPrice}元
				清空购物车
				去结账
			
		
		
		
			
				您还没有添加商品到购物车，去商城逛逛吧！！

8 删除购物车的商品

CartServlet,先设置cart的删除标签的跳转地址（执行删除商品项deleteItem方法）

					删除

//删除商品项
   protected void deleteItem(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //1 获取要删除的商品id
       int id = WebUtils.parseInt(request.getParameter("id"),0);

       //购物车不为空时才可以删除
       Cart cart = (Cart) request.getSession().getAttribute("cart");
       if (cart != null){
           cart.deleteItem(id);
           //重定向回原来浏览的页面
           response.sendRedirect(request.getHeader("Referer"));
       }
   }

添加点击响应事件，提示用户

9 清空购物车

cart.jsp

				清空购物车

CartServlet

    //清空购物车
    protected void clear(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        if (cart != null){
            cart.clear();
            //重定向回原来浏览的页面
            response.sendRedirect(request.getHeader("Referer"));
        }
    }

10 修改购物车商品项的数量

将数量的表格修改为文本框

添加文本框的内容改变触发函数change

CartServlet的updateCount方法

   //修改商品数量
   protected void updateCount(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //获取要修改的商品id和数量
       int id = WebUtils.parseInt(request.getParameter("id"), 0);
       int count = WebUtils.parseInt(request.getParameter("count"), 0);
       Cart cart = (Cart) request.getSession().getAttribute("cart");
       if (cart != null){
           cart.updateCount(id,count);
           response.sendRedirect(request.getHeader("Referer"));
       }
   }

11 首页购物车数据展示

将刚才添加的商品的信息和总数量显示在首页上,我们把它保存在Session域中

addItem()方法

//将最后一个添加的商品保存在Session域中
       request.getSession().setAttribute("lastName",item.getName());

client/index.jsp

			
				<%--购物车为空--%>
				
					
						您的购物车中还没有商品
					
				
					<%--购物车不为空--%>
				
					您的购物车中有 ${sessionScope.cart.totalCount} 件商品
					
						您刚刚将${sessionScope.lastName}加入到了购物车中

第七阶段

1 订单模块

2 实现订单模块

数据库表

t_order数据库表的创建

#创建订单表
CREATE TABLE t_order(
	`order_id` VARCHAR(50) PRIMARY KEY,#订单编号
	`create_time` DATETIME,#创建时间
	`price` DECIMAL(11,2),#价格
	`status` INT,#状态
	`user_id` INT,#用户id
	FOREIGN KEY(`user_id`) REFERENCES t_user(`id`)
);

t_order_item表的创建

create table t_order_item(
	`id` int primary key auto_increment,#订单项id
	`name`  varchar(100),#订单项商品name
	`count` int,#订单项数量
	`price` decimal(11,2),#订单项价格
	`total_price` decimal(11,2),#订单项总价格
	`order_id` varchar(50),#订单编号
	foreign key(`order_id`) references t_order(`order_id`) 
);

数据模型Order和OrderItem

Order类

public class Order {

   private String orderId;
   private Date createTime;
   private BigDecimal price;

   private Integer status = 0;
   //0表示未发货，1表示已发货，2表示已签收

   private Integer userId;
}

OrderItem类

public class OrderItem {

   private Integer id;
   private String name;
   private Integer count;
   private BigDecimal price;
   private BigDecimal totalPrice;
   private String orderId;
}

DAO和测试

OrderDao接口

public interface OrderDao {

   int saveOrder(Order order);
}

OrderDaoImpl实现类

public class OrderDaoImpl extends BaseDao implements OrderDao {
   @Override
   public int saveOrder(Order order) {
       String sql = "insert into t_order(`order_id`,`create_time`,`price`,`status`,`user_id`)values(?,?,?,?,?)";
       return update(sql,order.getOrderId(),order.getCreateTime(),order.getPrice(),order.getStatus(),order.getUserId());
   }
}

OrderDaoTest测试类

   @Test
   public void saveOrder() {
       OrderDao orderDao = new OrderDaoImpl();
       orderDao.saveOrder(new Order("2232425211",new Date(),new BigDecimal(100),0,1));
   }

OrderItemDao接口

public interface OrderItemDao {

   int saveOrderItem(OrderItem orderItem);
}

OrderItemDaoImpl实现类

public class OrderItemDaoImpl extends BaseDao implements OrderItemDao {
   @Override
   public int saveOrderItem(OrderItem orderItem) {
       String sql = "insert into t_order_item(`name`,`count`,`price`,`total_price`,`order_id`)values(?,?,?,?,?)";
       return update(sql,orderItem.getName(),orderItem.getCount(),orderItem.getPrice(),orderItem.getTotalPrice(),orderItem.getOrderId());
   }
}

OrderItemTest测试类

   @Test
   public void saveOrderItem() {
       OrderItemDao orderItemDao = new OrderItemDaoImpl();
       orderItemDao.saveOrderItem(new OrderItem(null,"java从入门到放弃",1 ,new BigDecimal(100),new BigDecimal(100),"2232425211"));
   }

Service和测试

OrderService接口

public interface OrderService {
   String createOrder(Cart cart,Integer userId);
}

OrderServiceImpl实现类

public class OrderServiceImpl implements OrderService {

   private OrderDao orderDao = new OrderDaoImpl();
   private OrderItemDao orderItemDao = new OrderItemDaoImpl();

   @Override
   public String createOrder(Cart cart, Integer userId) {
       //生成订单号--唯一性
       String orderId = System.currentTimeMillis()+""+userId;
       //创建一个订单对象
       Order order = new Order(orderId,new Date(),cart.getTotalPrice(),0,userId);
       //保存订单
       orderDao.saveOrder(order);

       //购物车中的商品就是订单项，我们将它们转化成订单项对象
       //遍历购物车中的商品项转化成订单项
       for (Map.Entry<Integer, CartItem> entry : cart.getItems().entrySet()){
           //获取每一个购物车中的商品
           CartItem cartItem = entry.getValue();
           //转化为每一个订单
           OrderItem orderItem = new OrderItem(null,cartItem.getName(),cartItem.getCount(),cartItem.getPrice(),cartItem.getTotalPrice(),orderId);
           //保存订单到数据库
           orderItemDao.saveOrderItem(orderItem);
       }
       //生成订单之后，购物车要清空
       cart.clear();

       return orderId;
   }
}

OrderServiceTest测试类

   @Test
   public void createOrder() {
       Cart cart = new Cart();
       cart.addItem(new CartItem(1,"java从入门到放弃",1,new BigDecimal(50),new BigDecimal(50)));
       cart.addItem(new CartItem(1,"java从入门到放弃",1,new BigDecimal(50),new BigDecimal(50)));
       cart.addItem(new CartItem(2,"python实践",1,new BigDecimal(100),new BigDecimal(100)));

       OrderService orderService = new OrderServiceImpl();
       orderService.createOrder(cart,1);
   }

结账功能实现

OrderServlet程序（生成订单createOrder()方法）

public class OrderServlet extends BaseServlet {

    private OrderService orderService = new OrderServiceImpl();

    //生成订单
    protected void createOrder(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //先获取Cart购物车对象
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        //获取Userid
        User loginUser = (User) request.getSession().getAttribute("user");

        //订单信息必须要有用户的id,如果用户还没有登录，Session域中获取不到，那我们就要让他跳转到登录界面
        if (loginUser == null){
            //请求转发到登录页面
            request.getRequestDispatcher("/pages/user/login.jsp").forward(request,response);
            //下面的语句没有必要执行，所以返回
            return;
        }

        Integer userId = loginUser.getId();

        //创建订单之后返回订单号
        String orderId = orderService.createOrder(cart, userId);

        //将订单号保存到Session域中
        request.setAttribute("orderId",orderId);

        //请求转发到/pages/cart/checkout.jsp
        request.getRequestDispatcher("/pages/cart/checkout.jsp").forward(request,response);

    }
}

web.xml

   <servlet>
       <servlet-name>OrderServletservlet-name>
       <servlet-class>com.atgw.web.OrderServletservlet-class>
   servlet>
   <servlet-mapping>
       <servlet-name>OrderServletservlet-name>
       <url-pattern>/orderServleturl-pattern>
   servlet-mapping>

cart.jsp

				去结账

checkout.jsp

		你的订单已结算，订单号为:${requestScope.orderId}

解决生成订单的bug

bug1(避免表单重复提交)

createOrder()

//将订单号保存到Session域中
        //request.setAttribute("orderId",orderId);(使用重定向时，request域就获取不到数据)
        request.getSession().setAttribute("orderId",orderId);

        //请求转发到/pages/cart/checkout.jsp
        //request.getRequestDispatcher("/pages/cart/checkout.jsp").forward(request,response);
        //防止表单重复提交，要使用重定向
        response.sendRedirect(request.getContextPath()+"/pages/cart/checkout.jsp");
    }

checkout.jsp

		你的订单已结算，订单号为:${sessionScope.orderId}

bug2(提交订单之后，原来商品的销量和库存要改变)

OrderServiceImpl中createOrder()

           //更新库存和销量
           Book book = bookDao.queryBookById(cartItem.getId());
           book.setSales(book.getSales() + cartItem.getCount());
           book.setStock(book.getStock() - cartItem.getCount());
           bookDao.updateBook(book);

第八阶段

1 使用Filter过滤器拦截/pages/manager/所有内容，实现权限检查

ManagerServlet中doFilter()方法

public class ManagerFilter implements Filter {
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {

   }

   //权限检查
   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
       HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

       //判断用户是否登录
       Object user = httpServletRequest.getSession().getAttribute("user");
       if(user == null){
           // 如果没有登录，请求转发到登录页面
           httpServletRequest.getRequestDispatcher("/pages/user/login.jsp").forward(servletRequest,servletResponse);
       }else{
           filterChain.doFilter(servletRequest,servletResponse);
       }
   }

   @Override
   public void destroy() {

   }
}

配置ManagerFilter过滤器

   <filter>
       <filter-name>ManagerFilterfilter-name>
       <filter-class>com.atgw.filter.ManagerFilterfilter-class>
   filter>
   <filter-mapping>
       <filter-name>ManagerFilterfilter-name>
       <url-pattern>/pages/manager/*url-pattern>
       <url-pattern>/manager/bookServleturl-pattern>
   filter-mapping>

2 ThreadLocal的使用

它可以解决多线程的数据安全问题

ThreadLocal可以给当前线程关联一个数据（可以是普通变量，可以是对象，也可以是数组，集合）

特点

ThreadLocal可以为当前线程关联一个数据（像Map一样）

每一个ThreadLocal对象，只能为当前线程关联一个数据，如果要为当前线程关联多个数据，就需要使用多个ThreadLocal对象实例

每个ThreadLocal对象实例定义的时候，一般都是static类型

ThreadLocal中保存数据，在线程销毁后，会有JVM虚拟机自动释放

3 使用ThreadLocal来确保所有操作都使用一个Connection来处理事务

JDBC数据库事务的处理

Connection conn = JdbcUtils.getConnection();
try{
   conn.setAutoCommit(false);//设置为手动管理事务
   
   执行一系列的jdbc操作
       
   conn.commit;//手动提交事务
}catch(Exception e){
   conn.rollback();//回滚事务
}finally{
   JdbcUtils.close(conn);
}

改变JdbcUtils中获取连接的方法

//创建一个ThreadLocal对象，将一个数据库连接放在其中（保证事务的实现，连接的唯一）
   private static ThreadLocal<Connection> conns = new ThreadLocal<>();

获取连接

//获取连接
   //返回null说明获取连接失败
   public static Connection getConnection(){
       //从ThreadLocal对象conns中取出连接
       Connection conn = conns.get();
       if(conn == null){
           try {
               //如果没有，就从数据库连接池中获取
               conn = dataSource.getConnection();

               //保存在ThreadLocal对象conns中，供后面的Jdbc操作
               conns.set(conn);

               conn.setAutoCommit(false);//设置为手动管理,手动提交
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
       return conn;
   }

提交事务并关闭连接

//提交事务并关闭连接
   public static void commitAndClose(){
       Connection connection = conns.get();
       if (connection != null){//不等于null,说明之前使用过，操作过数据库
           try {
               connection.commit();//提交事务
           } catch (SQLException e) {
               e.printStackTrace();
           }finally {
               try {
                   connection.close();//关闭连接
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
       }
       //一定要remove(),否则就会出错，（Tomcat服务器底层使用了线程池技术，不移除可以线程池会溢出）
       conns.remove();
   }

回滚事务并关闭连接

//回滚事务并关闭连接
   public static void rollbackAndClose(){
       Connection connection = conns.get();
       if (connection != null){//不等于null,说明之前使用过，操作过数据库
           try {
               connection.rollback();//提交事务
           } catch (SQLException e) {
               e.printStackTrace();
           }finally {
               try {
                   connection.close();//关闭连接
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
       }
       //一定要remove(),否则就会出错，（Tomcat服务器底层使用了线程池技术，不移除可以线程池会溢出）
       conns.remove();
   }

在Dao层，我们不用关闭连接，因为后面和前面使用的是一个连接对象，我们只需要在这一层把所有方法的异常抛出

catch (SQLException e) {
           e.printStackTrace();
           throw new RuntimeException(e);
       }

OrderServlet程序

//创建订单之后返回订单号
        String orderId = null;
        try{
            orderId =  orderService.createOrder(cart, userId);

            JdbcUtils.commitAndClose();//没有异常，提交

        }catch (Exception e){
            JdbcUtils.rollbackAndClose();//有异常，回滚

            e.printStackTrace();
        }

4 使用Filter过滤器给所有Service方法加上try-catch来管理事务

TransactionFilter过滤器

给 filterChain.doFilter()方法加上了try-catch，然后在web.xml中配置了拦截地址（所有请求），所以相当于对所有的Service方法加上了try-catch
底层实现，把异常抛给外边的Filter程序，对异常进行处理（提交事务或回滚事务）

   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
       try {
           filterChain.doFilter(servletRequest,servletResponse);

           JdbcUtils.commitAndClose();//提交事务
       }catch (Exception e){
           JdbcUtils.rollbackAndClose();//回滚事务
           e.printStackTrace();
       }
   }

配置web.xml（对所有请求都进行拦截）

   <filter>
       <filter-name>TransactionFilterfilter-name>
       <filter-class>com.atgw.filter.TransactionFilterfilter-class>
   filter>
   <filter-mapping>
       <filter-name>TransactionFilterfilter-name>
       
       <url-pattern>/*url-pattern>
   filter-mapping>

5 将所有异常统一交给Tomcat,让Tomcat展示友好的错误信息页面

错误404提示页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>



   
   



很抱歉，您访问的页面不存在或已经被删除!！
返回首页

错误500提示页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>



   
   



很抱歉，您访问的后台程序出现了错误，程序员小哥，正在努力的为您抢修！！
返回首页

web.xml文件配置错误提示页面

   
   <error-page>
       
       <error-code>500error-code>
       
       <location>/pages/error/error500.jsplocation>
   error-page>

   <error-page>
       
       <error-code>404error-code>
       
       <location>/pages/error/error404.jsplocation>
   error-page>

第九阶段

使用AJAX验证表单信息

UserServlet程序

开始ajax程序发送请求给服务器，把用户名信息追加到了请求地址中

我们在Servlet程序中可以获取到请求地址的用户名参数，然后对其进行数据库的访问，判断这个用户名是否存在

并把其是否存在的信息封装到Map集合中，使用响应的字符输出流输出数据，也就是存在了data中

在页面上使用data获取结果信息，做出相应的提示信息

     //验证表单的用户名信息
    protected void ajaxExistsUsername(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
        //获取请求的参数username
        String username = request.getParameter("username");
        //判断用户名是否存在
        boolean existsUsername = userService.existsUsername(username);
        //把返回的结果封装为Map对象
        Map<String,Object> resultMap = new HashMap<>();
        resultMap.put("existsUsername",existsUsername);

        Gson gson = new Gson();
        String json = gson.toJson(resultMap);

        //响应的字符输出流输出数据
        response.getWriter().write(json);
    }

regist.jsp页面中，验证表单的信息

使用AJAX把商品添加到购物车

CartServlet程序，添加购物车

因为添加购物车时，页面需要对购物车中总的商品数量和最后一个添加的商品名做出显示，所以我们需要返回这两个参数
使用Map集合存储，将数据发送给响应端

//使用AJAX添加购物车
   //添加购物车
   protected void ajaxAddItem(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

       //1 获取请求的参数，商品编号
       int id = WebUtils.parseInt(request.getParameter("id"),0);
       //2 调用bookServlet.queryBookById() 查询获取到图书的信息
       Book book = bookService.QueryBookById(id);
       //3 把图书信息，转换成CartItem商品项
       CartItem item = new CartItem(book.getId(), book.getName(), 1, book.getPrice(), book.getPrice());
       //4 调用Cart.addItem(CartItem) 添加商品项
       /*因为在添加购物车时，购物车只有一个，我们把它放在Session中
        * 刚开始添加购物车时，先判断Session中是否有购物车，如果没有，
        * 则新创建一个存放在Session域中 */
       Cart cart = (Cart) request.getSession().getAttribute("cart");
       if (cart == null){
           cart = new Cart();
           request.getSession().setAttribute("cart",cart);
       }
       cart.addItem(item);

       //将最后一个添加的商品保存在Session域中
       request.getSession().setAttribute("lastName",item.getName());

       //返回购物车总的商品数量和最后一个添加的商品名称
       Map<String,Object> resultMap = new HashMap<>();
       resultMap.put("totalCount",cart.getTotalCount());
       resultMap.put("lastName",item.getName());

       Gson gson = new Gson();
       String s = gson.toJson(resultMap);

       //响应发送数据
       res
           ponse.getWriter().write(s);
   }

client/index.jsp（对其进行重写，使用AJAX来显示页面提示信息）

			
				<%--购物车为空--%>
				
                   
					
						您的购物车中还没有商品
					
				
					<%--购物车不为空--%>
				
					您的购物车中有 ${sessionScope.cart.totalCount} 件商品
					
						您刚刚将${sessionScope.lastName}加入到了购物车中

获取服务器响应的数据,保存在data中
然后对其进行显示

你可能感兴趣的:(项目,Java,JavaWeb,书城,java)

关于沟通这件事，项目经理不需要每次都面对面进行流程大师兄
很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
抖音乐买买怎么加入赚钱?赚钱方法是什么测评君高省
你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
git - Webhook让部署自动化大猪大猪
我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
冬天短期的暴利小生意有哪些？那些小生意适合新手做？一起高省
短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts 信息可视化数据分析
ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
01-Git初识 Meereen Git git
01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
果然只有离职的时候，才有人敢说真话！ return2ok
今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析北京云巴巴信息技术有限公司产品经理需求分析
在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案 RPA中国人工智能 AIGC 传媒
在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Spring的注解积累 yijiesuifeng spring 注解
用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。如：在base-package指明一个包 <context:component-sc
传感器百合不是茶 android 传感器
android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件下面就以重力传感器为例; 1,在onCreate中获得传感器服务 private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
[光磁与探测]金吕玉衣的意义 comsci
这是一个古代人的秘密:现在告诉大家信不信由你们: 穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星这就是为什么古代
精简的反序打印某个数沐刃青蛟打印
以前看到一些让求反序打印某个数的程序。比如：输入123，输出321。记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。似乎最后是用到%和/方法解决的。而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）代码如下： long num, num1=0;
PHP：6种方法获取文件的扩展名 IT独行者 PHP 扩展名
PHP：6种方法获取文件的扩展名 1、字符串查找和截取的方法 1 $extension = substr ( strrchr ( $file , '.' ), 1); 2、字符串查找和截取的方法二 1 $extension = substr
面试111 文强chu 面试
1事务隔离级别有那些，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器（一次） 4 过滤器和拦截器的区别（频率也挺高） 5 final，finally final
XML的四种解析方式小桔子 dom jdom dom4j sax
在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。　　预备　　测试环境：　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
wordpress中常见的操作 aichenglong 中文注册 wordpress 移除菜单
1 wordpress中使用中文名注册解决办法 1)使用插件 2)修改wp源代码进入到wp-include/formatting.php文件中找到 function sanitize_user( $username, $strict = false
小飞飞学管理-1 alafqq 管理
项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。结合我自己经历写下心得对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
IO输入输出部分探讨百合不是茶 IO
//文件处理在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */ //1，运用File类对文件目录和属性进行操作 //在工程中线创建一个text.txt
getElementById的用法 bijian1013 element
getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。返回具有指定ID属性值的第一个对象的一个引用。语法： &n
励志经典语录 bijian1013 励志人生
经典语录1: 哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
[MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。本篇介绍MongoDB的切片(Sharding) 1.何时需要分片 &nbs
【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
yum方式部署zabbix ronin47 yum方式部署zabbix
安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EE Hibernate4
今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
Netty源码学习-FrameDecoder bylijinnan java netty
Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
SQL行列转换方法 chicony 行列转换
create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
中文编码测试 ctrain 编码
循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
hive 客户端查询报堆内存溢出解决方法 daizj hive 堆内存溢出
hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 问题原因： hive堆内存默认为256M 这个问题的解决方法为：修改/us
人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
Eclipse简单有用的配置 dcj3sjt126com eclipse
1、显示行号 Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers 2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
在tomcat上面安装solr4.8.0全过程 eksliang Solr solr4.0后的版本安装 solr4.8.0安装
转载请出自出处： http://eksliang.iteye.com/blog/2096478 首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了第一步：当然是下载去官网上下载最新的solr版本，下载地址
Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞 android APP 分析
点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。 0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。针对序列化对象而出现的拒绝服务主要
HoverTree项目已经实现分层 hvt 编程 .net Web C#ASP.ENT
HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
Google Maps API v3: Remove Markers 移除标记天梯梦 google maps api
Simply do the following: I. Declare a global variable: var markersArray = []; II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
jQuery选择器总结 lq38366 jquery 选择器
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
基础数据结构和算法六：Quick sort sunwinner Algorithm Quicksort
Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作刘星宇 html Web
今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。方法如下：
Mybatis实用Mapper SQL汇总示例 wdmcygah sql mysql mybatis 实用
Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，

按字母分类： A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 其他