图书管理系统【用户、购买、订单模块、添加权限】

用户模块

要登陆后才能购买，因此我们先写购买模块.

设计实体


    private String id;
    private String username;
    private String password;
    private String email;
    private String cellphone;
    private String address;

    //各种setter、getter

设计数据库表


CREATE TABLE user (

  id        VARCHAR(40) PRIMARY KEY,
  username  VARCHAR(20) NOT NULL,
  cellphone VARCHAR(20) NOT NULL,
  address   VARCHAR(40) NOT NULL,
  email     VARCHAR(30),
  password  VARCHAR(30) NOT NULL

);

编写DAO


/**
 * 用户的登录注册模块
 * 1：登陆
 * 2：注册
 * 3：根据id查找具体的用户
 */
public class UserDaoImpl {



    public void register(User user) {

        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "INSERT INTO user (id,username,cellphone,address,email,password) VALUES(?,?,?,?,?,?)";
        try {

            queryRunner.update(sql, new Object[]{user.getId(),user.getUsername(), user.getCellphone(), user.getAddress(), user.getEmail(), user.getPassword()});
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public User login(String username, String password) {

        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "SELECT * FROM user WHERE username = ? AND password=?";
        try {

            return (User) queryRunner.query(sql, new Object[]{username, password}, new BeanHandler(User.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public User find(String id) {

        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "SELECT * FROM user WHERE id=?";
        try {

            return (User) queryRunner.query(sql, id, new BeanHandler(User.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

}

测试DAO


public class UserDemo {
    UserDaoImpl userDao = new UserDaoImpl();

    @Test
    public void add() {

        User user = new User();
        user.setId("1");
        user.setUsername("zhong");
        user.setPassword("123");
        user.setCellphone("10085");
        user.setAddress("广州萝岗");
        user.setEmail("40368324234234@QQ.com");

        userDao.register(user);
    }

    @Test
    public void find() {

        String id = "1";
        User user = userDao.find(id);

        System.out.println(user.getEmail());
    }

    @Test
    public void login() {
        String username = "zhong";
        String password = "123";
        User user = userDao.login(username, password);

        System.out.println(user.getAddress());
    }
}

抽取DAO


public interface UserDao {
    void register(User user);

    User login(String username, String password);

    User find(String id);
}

编写Service


    private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

    public void registerUser(User user) {
        userDao.register(user);
    }
    
    public User loginUser(String username,String password) {
        return userDao.login(username, password);
    }
    
    public User findUser(String id) {
        return userDao.find(id);
    }

前台样式

head.jsp


<div id="User">
    用户名：<input type="text" name="username">
    密码：<input type="password" name="password">
    <button name="login">登陆</button>
    <button name="register">注册</button>
</div>

head.css


#body {
    position: relative;
}
#user {
    position: absolute;
    margin-top: 130px;
    margin-left: 1364px;
}

效果：

这里写图片描述

实现登陆注册功能

当点击登陆按钮的时候，把数据带过去给Servlet，让Servlet调用BusinessService方法，实现登陆。注册同理.....因此，我们需要用到JavaScript代码

head.jsp


<c:if test="${user==null}" >
<div id="User">
    用户名：<input type="text" id="username">
    密码：<input type="password" id="password">
    <button name="login" onclick="login()">登陆</button>
    <button name="register" onclick="register()">注册</button>
</div>
</c:if>

<c:if test="${user!=null}" >
    <div id="User">
        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;欢迎您：${user.username}&nbsp;&nbsp;&nbsp;&nbsp;<a href="${pageContext.request.contextPath}/UserServlet?method=Logout">注销</a>
    </div>
</c:if>

javaScript代码


    <script type="text/javascript">

        function login() {
            //得到输入框的数据
            var username = document.getElementById("username").value;
            var password = document.getElementById("password").value;

            //跳转到相对应的Servlet上
            window.location.href = "${pageContext.request.contextPath}/UserServlet?method=login&username=" + username + "&password=" + password;
        }

        function register() {

            //跳转到注册页面
            window.location.href = "${pageContext.request.contextPath}/client/register.jsp";
        }
    </script>

UserServlet



        String method = request.getParameter("method");

        BussinessServiceImpl service = new BussinessServiceImpl();
        if (method.equals("login")) {

            try {
                //得到页面传递过来的数据
                String username = request.getParameter("username");
                String password = request.getParameter("password");
                User user = service.loginUser(username, password);

                request.getSession().setAttribute("user",user);
                request.getRequestDispatcher("/client/head.jsp").forward(request, response);

            } catch (Exception e) {
                request.setAttribute("message", "登陆失败了！");
                request.getRequestDispatcher("/message.jsp").forward(request, response);
            }

        } else if (method.equals("register")) {

            try {
                //得到JSP传递过来的数据，封装成Bean对象
                User user = WebUtils.request2Bean(request, User.class);
                user.setId(WebUtils.makeId());

                service.registerUser(user);

                request.setAttribute("message", "注册成功了！");

            } catch (Exception e) {
                e.printStackTrace();
                request.setAttribute("message", "注册失败了！");
            }
            request.getRequestDispatcher("/message.jsp").forward(request, response);
        } else if (method.equals("Logout")) {

            //销毁session
            request.getSession().invalidate();

            //回到首页
            request.getRequestDispatcher("/client/head.jsp").forward(request, response);

        }

购买模块

在显示图书的时候，顺便添加购买的超链接

    <li><a href="#">购买</a></li>

设计购物车实体

如果不清楚为什么这样设计，可参考我之前的博文：http://blog.csdn.net/hon_3y/article/details/56481439#t5

Cart实体


public class Cart {

    private Map<String, CartItem> map = new HashMap<>();
    private double price;


    //提供把商品添加到购物的功能
    public void addBook2Cart(Book book) {

        //得到对应的购物项
        CartItem cartItem = map.get(book.getId());

        //如果是null，说明购物车还没有该购物项
        if (cartItem == null) {
            cartItem = new CartItem();
            cartItem.setQuantity(1);
            cartItem.setBook(book);
            cartItem.setPrice(book.getPrice());

            //把购物项加到购物车中
            map.put(book.getId(), cartItem);
        } else {

            //如果购物车有该购物项了，那么将购物项的数量+1
            cartItem.setQuantity(cartItem.getQuantity() + 1);
        }
    }


    //购物车的价钱是购物项价钱的总和
    public double getPrice() {

        double totalPrice = 0;
        for (Map.Entry<String, CartItem> me : map.entrySet()) {
            CartItem cartItem = me.getValue();
            totalPrice += cartItem.getPrice();
        }

        return totalPrice;
    }

    public Map<String, CartItem> getMap() {
        return map;
    }

    public void setMap(Map<String, CartItem> map) {
        this.map = map;
    }


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

设计购物项实体


public class CartItem {

    private Book book;
    private double price;
    private int quantity;

    public double getPrice() {
        return this.book.getPrice() * this.quantity;
    }

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

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }
    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
}

处理用户想要买的书籍Servlet

    <li><a href="${pageContext.request
.contextPath}/BuyServlet?book_id=${book.id}">购买</a></li>

BuyServlet


        BussinessServiceImpl service = new BussinessServiceImpl();

        //先检查该用户是否登陆了。
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            request.setAttribute("message", "您还没登陆，请登陆了再来购买");
            request.getRequestDispatcher("/message.jsp").forward(request, response);
            return ;
        }

        //如果登陆了...

        //得到该用户的购物车
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        if (cart == null) {
            cart = new Cart();
            request.getSession().setAttribute("cart", cart);
        }

        //得到用户想买的书籍
        String book_id = request.getParameter("book_id");
        Book book = service.findBook(book_id);

        //把书籍添加到购物车中
        service.buyBook(cart, book);
        request.setAttribute("message", "该商品已添加到购物车中");
        request.getRequestDispatcher("/message.jsp").forward(request,response);

提供显示购物车商品的Servlet


        //先判断该用户是否登陆了
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            request.setAttribute("message", "您还没有登陆呢！");
            request.getRequestDispatcher("/message.jsp").forward(request, response);
            return;
        }

        //如果登陆了.....
        Cart cart = (Cart) request.getSession().getAttribute("cart");

        //把该用户的购物车给JSP页面显示
        request.setAttribute("cart", cart);
        request.getRequestDispatcher("/client/listCart.jsp").forward(request, response);

显示购物车的JSP页面


<c:if test="${empty(cart.map)}">

    您还没有购买过任何商品哦！！！
</c:if>


<table border="1px">
    <c:if test="${!empty(cart.map)}">
        <h1>您购物车下有如下的商品：</h1><br>

        <tr>
            <td>书名：</td>
            <td>作者：</td>
            <td>数量：</td>
            <td>价钱：</td>
        </tr>
        <c:forEach items="${cart.map}" var="cartItme">


            <tr>
                <td>${cartItme.value.book.name}</td>
                <td>${cartItme.value.book.author}</td>
                <td>${cartItme.value.quantity}</td>
                <td>${cartItme.value.price}</td>
            </tr>
        </c:forEach>

    </c:if>
</table>

效果：

这里写图片描述

订单模块

在前台用户界面中，当用户要把购物车付款时，应该提供生成订单的超链接....

这里写图片描述

设计订单实体

订单应该包含id,收货人信息,下单的时间，订单的总价,订单的状态【有无发货】..而不应该包含商品的信息的。商品的信息用一个专门的”订单项“来表示

一个订单对应多个订单项，这是一对多的关系！

    private String id;
    
    //下单的时间、日期、状态
    private Date date;
    private double price;
    private boolean state;
    
    //一个用户可以有多个订单，把用户记住
    private String user_id;

    //一个订单中有多个订单项
    private Set<OrderItem> items = new HashSet<>();

    //各种的setter和getter

设计订单项实体


    private String id;


    //一本书对应多个订单项，订单项一定是由书组成，记住书
    private String book_id;

    private double price;
    private int quantity;

    //各种的setter和getter

设计数据库表

订单表

mysql不能创建名为”order”的表，后边加个s就可以



CREATE TABLE orders (
  id      VARCHAR(40) PRIMARY KEY,
  date    DATE        NOT NULL,
  user_id VARCHAR(40) NOT NULL,
  state   BOOLEAN,
  price   DOUBLE,
  CONSTRAINT user_id_FK FOREIGN KEY (user_id) REFERENCES user (id)
);

订单项表：


CREATE TABLE orderItem (
  id       VARCHAR(40) PRIMARY KEY,
  price    DOUBLE,
  quantity INT,
  order_id VARCHAR(40) ,
  book_id  VARCHAR(40) ,
  CONSTRAINT order_id_FK FOREIGN KEY (order_id) REFERENCES orders (id),
  CONSTRAINT book_id_FK FOREIGN KEY (book_id) REFERENCES book (id)
);

表之间的结构：

这里写图片描述

设计Dao


public class OrderDaoImpl implements zhongfucheng.dao.OrderDao {

    @Override
    public void addOrder(Order order) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());
        String sql1 = "INSERT INTO orders(id,ordertime,user_id,state,price) VALUES(?,?,?,?,?)";
        try {
            //订单的基本信息
            queryRunner.update(sql1, new Object[]{order.getId(), order.getOrdertime(), order.getUser_id(), order.isState(), order.getPrice()});

            //订单项的信息
            String sql2 = "INSERT INTO orderItem(id,price,quantity,order_id,book_id) VALUES(?,?,?,?,?)";

            Set<OrderItem> items = order.getItems();

            for (OrderItem item : items) {
                queryRunner.update(sql2, new Object[]{item.getId(), item.getPrice(), item.getQuantity(), item.getOrder_id(), item.getBook_id()});
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Order findOrder(String id) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        Order order;
        try {
            //找出订单的基本信息
            String sql = "SELECT * FROM orders WHERE id=?";
            order = (Order) queryRunner.query(sql, new BeanHandler(Order.class), new Object[]{id});

            //找出订单的所有订单项
            String sql2 = "SELECT * FROM orderItem WHERE order_id=?";
            List<OrderItem> list = (List<OrderItem>) queryRunner.query(sql2, new BeanListHandler(OrderItem.class), new Object[]{order.getId()});

            System.out.println("这是数据库拿到的list集合："+list.size());


            //将所有订单项装到订单里边
            order.getItems().addAll(list);
            System.out.println("这是数据库拿到的"+order.getItems().size());


            //找出该订单是属于哪一个用户的
            String sql3 = "SELECT * FROM orders o,user u WHERE o.user_id=u.id AND o.id=? ";
            User user = (User) queryRunner.query(sql3, new BeanHandler(User.class), new Object[]{order.getId()});

            order.setUser_id(user.getId());
            return order;


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


    //更新订单的状态
    public void updateState(String id) {

        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "UPDATE orders SET state=? WHERE id=?";

        try {
            queryRunner.update(sql, new Object[]{true, id});
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //查看已经发货或没发货的订单信息
    public List<Order> getAllOrder(boolean state) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "SELECT * FROM orders WHERE state=? ";
        try {
            return (List<Order>) queryRunner.query(sql, new BeanListHandler(Order.class), new Object[]{state});
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //通过用户的id查找用户的订单，可能不止一个
    public List<Order> findUserOrder(String user_id) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "SELECT * FROM orders WHERE user_id=? ";

        try {
            return List<Order> queryRunner.query(sql, new BeanHandler(Order.class), new Object[]{user_id});

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

    }
}

二次更新

在编写dao的时候，尤其是Add方法。它是将所有数据都封装到Order对象上，然后取出数据，把数据插入到数据表中

其实，我们的Order和OrderItem的操作可以分开。OrderItem也可以另外编写一个Dao，那么我们在插入完Order对象之后，得到Order对象返回的主键，再调用OrderItemDao的方法来插入OrderItem的数据，这样我觉得会让代码清晰一些。
在OrderItemDao中接收的是一个List<OrderItem>，因为我们一个订单会对应多个订单项。

抽取成DAO接口


public interface OrderDao {
    void addOrder(Order order);

    Order findOrder(String id);

    List<Order> getAllOrder(boolean state);

    void updateState(String user_id);

     List<Order> findUserOrder(String user_id);
}

BussinessService

    private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);
    public void createOrder(Cart cart, User user) {

        //订单的基本信息
        String order_id = WebUtils.makeId();
        Order order = new Order();
        order.setId(order_id);
        order.setPrice(cart.getPrice());
        order.setOrdertime(new Date());
        order.setState(false);
        order.setUser_id(user.getId());


        //订单项的基本信息
        //得到每个购物项，购物项就作为订单项
        for (Map.Entry<String, CartItem> me : cart.getMap().entrySet()) {

            OrderItem orderItem = new OrderItem();
            CartItem cartItem = me.getValue();

            orderItem.setId(WebUtils.makeId());
            orderItem.setPrice(cartItem.getPrice());
            orderItem.setBook_id(cartItem.getBook().getId());
            orderItem.setQuantity(cartItem.getQuantity());
            orderItem.setOrder_id(order_id);
            order.getItems().add(orderItem);
        }

        orderDao.addOrder(order);

    }

    public Order findOrder(String user_id) {

        return orderDao.findOrder(user_id);
    }

    public List<Order> getAllOrder(boolean state) {
        return orderDao.getAllOrder(state);
    }

    public void sendOutOrder(String id) {

        orderDao.updateState(id);
    }

    public List<Order> findUserOrder(String user_id) {
        return orderDao.findUserOrder(user_id);
    }

生成订单的Servlet



        BussinessServiceImpl service = new BussinessServiceImpl();

        //检查该用户的购物车是否有商品
        Cart cart = (Cart) request.getSession().getAttribute("cart");
        if (cart == null) {
            request.setAttribute("message", "您购物车没有商品，无法生成订单");
            request.getRequestDispatcher("/message.jsp").forward(request, response);
            return;
        }

        //如果有商品，得到当前用户
        User user = (User) request.getSession().getAttribute("user");
        service.createOrder(cart, user);
        request.setAttribute("message", "订单已经生成了，准备好钱来收货把");
        request.getRequestDispatcher("/message.jsp").forward(request, response);
        return;

用户查询自己的订单Servlet


    <a href="${pageContext.request.contextPath}/LookOrder" target="body">查看订单</a>


        BussinessServiceImpl service = new BussinessServiceImpl();

        //检查该用户是否登陆了
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            request.setAttribute("message", "您还没登陆，等您登陆了再来看把");
            request.getRequestDispatcher("/message.jsp").forward(request, response);
            return;
        }

        //用户登陆了！
        Order order = service.findUserOrder(user.getId());

        //交给相对应的JSP 显示
        request.setAttribute("order", order);
        request.setAttribute("user",user);
        request.getRequestDispatcher("/client/listOrder.jsp").forward(request, response);
        return ;

显示订单数据的JSP


<c:if test="${order==null}">
    您还没有下过任何订单！！

</c:if>

<c:if test="${order!=null}">

    <table border="1px">

        <tr>
            <td>下单人：</td>
            <td>订单时间</td>
            <td>订单状态</td>
            <td>订单价钱</td>
        </tr>
        <tr>
            <td>${user.username}</td>
            <td>${order.ordertime}</td>
            <td>${order.state==false?"未发货":"已发货"}</td>
            <td>${order.price}</td>
        </tr>

    </table>

</c:if>

效果：

这里写图片描述

后台查询订单的状况Servlet


<a href="${pageContext.request.contextPath}/OrderServlet?state=false" target="body">待处理订单</a><br>
<a href="${pageContext.request.contextPath}/OrderServlet?state=true" target="body">已发货订单</a><br>


        BussinessServiceImpl service = new BussinessServiceImpl();
        String state = request.getParameter("state");

        if (state.equals("true")) {
            List<Order> list = service.getAllOrder(true);
            request.setAttribute("list",list);

        } else if (state.equals("false")) {
            List<Order> list = service.getAllOrder(false);
            request.setAttribute("list", list);
        }


        request.getRequestDispatcher("/background/listOrder.jsp").forward(request, response);

显示订单状况的JSP


<c:if test="${empty(list)}">

    还没有任何订单哦！

</c:if>

<c:if test="${!empty(list)}">

    <table border="1px">

        <tr>
            <td>下单人：</td>
            <td>订单时间</td>
            <td>订单状态</td>
            <td>订单价钱</td>
            <td>操作</td>
        </tr>

        <c:forEach items="${list}" var="order">
            <tr>
                <td>${order.user_id}</td>
                <td>${order.ordertime}</td>
                <td>${order.state==false?"未发货":"已发货"}</td>
                <td>${order.price}</td>
                <td>
                    <a href="${pageContext.request.contextPath}/orderItemServlet?order_id=${order.id}">查看详细信息</a>
                    <a href="#">删除</a>

                </td>
            </tr>
        </c:forEach>


    </table>


</c:if>

查看具体订单的详细信息Servlet


        BussinessServiceImpl service = new BussinessServiceImpl();

        //得到用户想要查看详细信息的表单
        String order_id = request.getParameter("order_id");

        Order order = service.findOrder(order_id);

        //将该order对象给相对应的JSP显示
        request.setAttribute("order", order);
        request.getRequestDispatcher("/background/listDetail.jsp").forward(request, response);

查看具体订单的详细信息JSP


<table border="1px">

   <tr>
       <td>书籍的编号</td>
       <td>价钱</td>
       <td>数量</td>
       <td>操作</td>
   </tr>
    <c:forEach items="${order.items}" var="item">
        <tr>
            <td>${item.book_id}</td>
            <td>${item.price}</td>
            <td>${item.quantity}</td>
            <td><a href="${pageContext.request.contextPath}/SendOutServlet?id=${order.id}">发货</a></td>
        </tr>
    </c:forEach>
</table>

处理发货的Servlet



        BussinessServiceImpl service = new BussinessServiceImpl();
        String id = request.getParameter("id");

        service.sendOutOrder(id);
        request.setAttribute("message", "已发货！");
        request.getRequestDispatcher("/message.jsp").forward(request, response);
        return;

效果:

这里写图片描述

添加权限控制

目前为止，我们已经学习了动态代理技术和注解技术了。于是我们想要为之前的bookStore项目添加权限控制.....

只有用户有权限的时候，后台管理才可以进行相对应的操作.....

实现思路

这里写图片描述

之前我们做权限管理系统的时候，是根据用户请求的URI来判断该链接是否需要权限的。这次我们使用动态代理的技术和注解来判断：用户调用该方法时，检查该方法是否需要权限...

根据MVC模式，我们在web层都是调用service层来实现功能的。那么我们具体的思路是这样的：

web层调用service层的时候，得到的并不是ServiceDao对象，而是我们的代理对象
在service层中的方法添加注解，如果方法上有注解，那么说明调用该方法需要权限...
当web层调用代理对象方法的时候，代理对象会判断该方法是否需要权限，再给出相对应的提示....

设计实体、数据库表

上次我们做的权限管理系统是引入了角色这个概念的，这次主要为了练习动态代理和注解技术，就以简单为主，不引入角色这个实体。直接是用户和权限之间的关系了。

Privilege实体


public class Privilege {

    private String id ;
    private String name;

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

数据库表

privilege表



CREATE TABLE privilege (

  id   VARCHAR(40) PRIMARY KEY,
  name VARCHAR(40)

);

privilege和user是多对多的关系，于是使用第三方表来维护他们的关系

user_privilege表



CREATE TABLE user_privilege (
  privilege_id VARCHAR(40),
  user_id      VARCHAR(40),

  PRIMARY KEY (privilege_id, user_id),
  CONSTRAINT privilege_id_FK FOREIGN KEY (privilege_id) REFERENCES privilege(id),
  CONSTRAINT user_id_FK1 FOREIGN KEY (user_id) REFERENCES user(id)

);

添加测试数据

为了方便，直接添加数据了。就不写详细的DAO了。

在数据库中添加了两个权限

这里写图片描述

为id为1的user添加了两个权限

这里写图片描述

编写DAO

后面在动态代理中，我们需要检查该用户是否有权限...那么就必须查找出该用户拥有的哪些权限。再看看用户有没有相对应的权限

    //查找用户的所有权限
    public List<Privilege> findUserPrivilege(String user_id) {
        QueryRunner queryRunner = new QueryRunner(Utils2DB.getDataSource());

        String sql = "SELECT p.* FROM privilege p, user_privilege up WHERE p.id = up.privilege_id AND up.user_id = ?";
        try {
            return (List<Privilege>) queryRunner.query(sql, new Object[]{user_id}, new BeanListHandler(Privilege.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

抽取到接口上


    List<Privilege> findUserPrivilege(String user_id);

注解模块

编写注解

@Retention(RetentionPolicy.RUNTIME)
public @interface permission {
    String value();
}

在Service层方法中需要权限的地方添加注解CategoryServiceImpl


    @permission("添加分类")
    /*添加分类*/
    public void addCategory(Category category) {
        categoryDao.addCategory(category);
    }


    /*查找分类*/
    public void findCategory(String id) {
        categoryDao.findCategory(id);
    }

    @permission("查找分类")
    /*查看分类*/
    public List<Category> getAllCategory() {
        return categoryDao.getAllCategory();
    }

抽取Service

把Service的方法抽取成ServiceDao。在Servlet中，也是通过ServiceFactory来得到Service的对象【和DaoFactory是类似的】

CategoryService


    @permission("添加分类")
    /*添加分类*/ void addCategory(Category category);

    /*查找分类*/
    void findCategory(String id);

    @permission("查找分类")
    /*查看分类*/ List<Category> getAllCategory();

ServiceFactory


public class ServiceDaoFactory {

    private static final ServiceDaoFactory factory = new ServiceDaoFactory();

    private ServiceDaoFactory() {
    }

    public static ServiceDaoFactory getInstance() {
        return factory;
    }


    //需要判断该用户是否有权限
    public <T> T createDao(String className, Class<T> clazz, final User user) {

        System.out.println("添加分类进来了！");

        try {
            //得到该类的类型
            final T t = (T) Class.forName(className).newInstance();
            //返回一个动态代理对象出去
            return (T) Proxy.newProxyInstance(ServiceDaoFactory.class.getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, PrivilegeException {
                    //判断用户调用的是什么方法
                    String methodName = method.getName();
                    System.out.println(methodName);

                    //得到用户调用的真实方法，注意参数！！！
                    Method method1 = t.getClass().getMethod(methodName,method.getParameterTypes());

                    //查看方法上有没有注解
                    permission permis = method1.getAnnotation(permission.class);

                    //如果注解为空，那么表示该方法并不需要权限，直接调用方法即可
                    if (permis == null) {
                        return method.invoke(t, args);
                    }

                    //如果注解不为空，得到注解上的权限
                    String privilege = permis.value();

                    //设置权限【后面通过它来判断用户的权限有没有自己】
                    Privilege p = new Privilege();
                    p.setName(privilege);

                    //到这里的时候，已经是需要权限了，那么判断用户是否登陆了
                    if (user == null) {

                        //这里抛出的异常是代理对象抛出的，sun公司会自动转换成运行期异常抛出，于是在Servlet上我们根据getCause()来判断是不是该异常，从而做出相对应的提示。
                        throw new PrivilegeException("对不起请先登陆");
                    }

                    //执行到这里用户已经登陆了，判断用户有没有权限
                    Method m = t.getClass().getMethod("findUserPrivilege", String.class);
                    List<Privilege> list = (List<Privilege>) m.invoke(t, user.getId());

                    //看下权限集合中有没有包含方法需要的权限。使用contains方法，在Privilege对象中需要重写hashCode和equals()
                    if (!list.contains(p)) {
                        //这里抛出的异常是代理对象抛出的，sun公司会自动转换成运行期异常抛出，于是在Servlet上我们根据getCause()来判断是不是该异常，从而做出相对应的提示。
                        throw new PrivilegeException("您没有权限，请联系管理员！");
                    }

                    //执行到这里的时候，已经有权限了，所以可以放行了
                    return method.invoke(t, args);
                }
            });

        } catch (Exception e) {
            new RuntimeException(e);
        }
        return null;
    }
}

PrivilegeExcetption

当用户没有登陆或者没有权限的时候，我们应该给用户一些友好的提示....于是我们自定义了PrivilegeException


public class PrivilegeException extends Exception {

    public PrivilegeException() {
        super();
    }

    public PrivilegeException(String message) {
        super(message);
    }

    public PrivilegeException(String message, Throwable cause) {
        super(message, cause);
    }

    public PrivilegeException(Throwable cause) {
        super(cause);
    }
}

我们继承的是Exception，通过方法名抛出去。但是我们是通过代理对象调用方法的，于是sun公司的策略就是把它们转换成运行期异常抛出去。

因此，我们就在Servlet上得到异常，再给出友好的提示。。

效果：

没有登陆的时候：

这里写图片描述

登陆了，但是没有相对应的权限的时候

这里写图片描述

登陆了，并且有权限

这里写图片描述

要点总结

该权限控制是十分优雅的，只要我在Service层中添加一个注解...那么当web层调用该方法的时候就需要判断用户有没有该权限....

外界调用Service层的方法是代理调用invoke()方法，我们在invoke()方法可以对其进行增强！
invoke()方法内部就是在查询调用该方法上有没有注解，如果没有注解，就可以直接调用。如果有注解，那么就得到注解的信息，判断该用户有没有权限来访问这个方法
在反射具体方法的时候，必须记得要给出相对应的参数！
在invoke()方法抛出的编译时期异常，java会自动转换成运行期异常进行抛出...
使用contains()方法时，就要重写该对象的hashCode()和equals()

图书管理系统【用户、购买、订单模块、添加权限】

用户模块

设计实体

设计数据库表

编写DAO

测试DAO

抽取DAO

编写Service

前台样式

实现登陆注册功能

购买模块

设计购物车实体

设计购物项实体

处理用户想要买的书籍Servlet

提供显示购物车商品的Servlet

显示购物车的JSP页面

效果：

订单模块

设计订单实体

设计订单项实体

设计数据库表

设计Dao

二次更新

抽取成DAO接口

BussinessService

生成订单的Servlet

用户查询自己的订单Servlet

显示订单数据的JSP

效果：

后台查询订单的状况Servlet

显示订单状况的JSP

查看具体订单的详细信息Servlet

查看具体订单的详细信息JSP

处理发货的Servlet

效果:

添加权限控制

实现思路

设计实体、数据库表

Privilege实体

数据库表

添加测试数据

编写DAO

抽取到接口上

注解模块

抽取Service

CategoryService

ServiceFactory

PrivilegeExcetption

效果：

要点总结

Java3y

引用和评论

呵，老板不过如此，SQL还是得看我

在Java程序中监听mysql的binlog

Jerry和您聊聊Chrome开发者工具

Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

Just for fun——迅速写完快速排序

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

💢线上高延迟请求排查

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊