基于SpringMVC的图书管理系统

最新推荐文章于 2024-06-19 02:09:22 发布

那片世界那片海

最新推荐文章于 2024-06-19 02:09:22 发布

阅读量4.4k

点赞数 15

分类专栏： JavaWeb 文章标签： spring java 后端 mybatis

本文链接：https://blog.csdn.net/weixin_50765519/article/details/117292858

版权

JavaWeb 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

这是本人经过Spring框架的学习，根据其他人项目的参考与改进，由此实现了一个较为基本的图书管理系统，也算是自己的一个学习经历吧，好了废话不多说，下面进入正题。

一、项目概述

功能性需求描述

图书（馆）管理系统是典型的信息管理系统,其开发主要包括以下部分：后台数据库的建立、维护，前端应用程序的开发。
对于前者，要建立起数据一致性和完整性强、数据安全性较好的数据库。而对于后者来说，需要的是应用程序功能完备,易使用等特点。

设计概述

1、界面设计简洁，友好（易于人机交互）
2、信息分类清晰，准确（全部图书，图书借阅情况，用户信息情况）
3、提高较好的查询能力（支持模糊查询）
4、支持图书馆工作人员对图书借阅、归还等基本的功能

实现功能

1、管理员对图书进行管理
2、管理员对借阅者（读者）信息的管理
3、管理员对借阅者借阅书本的归还管理
4、管理员登入管理
5、用户借阅查询，个人信息查询，借阅信息查询等
6、管理员/用户的密码更改

功能展示

管理员身份操作

以管理员身份登录后的首页，在这里可以进行图书的相关操作
在这里插入图片描述
管理员对读者进行管理

管理员查看所有用户书目借还记录

用户（读者）身份操作

以用户（读者）身份登陆后的首页，在这里可以进行图书的相关操作
在这里插入图片描述
用户（读者）修改个人账号信息

用户（读者）查看个人的借还记录

用户\管理员密码修改

在这里插入图片描述

二、系统详细设计

1、大框架的构建

要写好一个项目，首先最重要的就是构建项目的框架。有了框架，写一个项目就不会手忙脚乱，就会变得有计划，有规律，效率才能提高。
根据SpringMVC的三层架构，我们可以将项目分为这三大部分：

Model（模型）是应用程序中用于处理应用程序数据逻辑的部分，通常模型对象负责在数据库中存取数据。
View（视图）是应用程序中处理数据显示的部分，通常视图是依据模型数据创建的。
Controller（控制器）是应用程序中处理用户交互的部分，通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

在此三大模型之上，可以再细分：

dao层：这一层是数据持久层，正所谓数据持久化，就要和数据库打交道，所以这一层，需要做的便是有关于数据库的操作，例如图书的增删改查之类的。
controller层：这一层是控制层，控制前端界面-后台的数据交互与逻辑操作，例如从页面读取数据，发送数据之类的操作。（具体的业务）
entity层：这一层便是实体层，放置一个个实体，及其相应的set、get方法。如果想要对数据库进行一些操作（比如说读取）的话，就要先写entity层。
service层：这一层是服务层，负责模块间的数据交互与逻辑操作（模块间的业务）

做好大框架的构造后，下面就可以进行项目的准备工作了！

2、项目前期的准备工作

项目的前期准备工作有：

相关技术	名称
前端	jsp、css、html、JQuery、BootStrap
后端	SpringMVC、Mybatis
数据库	Mysql
开发环境	IDEA

预期实现的功能有：

角色	功能
普通用户（借阅者）	图书查询（查看全部图书），个人信息（查看或修改个人信息），借还情况，密码修改
管理员	图书管理（查看全部图书，增加图书），读者管理（查看全部读者，增加读者），借还管理，修改密码
未登录人员	登录系统，进入管理员或者普通用户界面

项目文件框架如下：

book：里面有controller,dao,entity,service
resources：里面放xml等配置文件
webapp：里面放网页有关的东西，static（里面放静态加载的文件，css,images,js），WEB-INF（jsp,web.xml文件等）
pom.xml文件：通过maven远程仓库，引入相关依赖包
mybatis映射文件：通过mybatis映射找到相应的sql语句

项目结构如图所示：

项目前期的准备工作基本上就做完了，下面进行项目中各逻辑方法的实现

三、各个功能的详细实现

此篇章较多，各位客官可以慢慢看，也可以选择最喜欢的部分看，话不多说，开始项目！

1、创建spring配置文件

由于项目基于Spring框架，需要用到spring配置文件来进行bean类的注入

<!-- 扫描类包，将标注Spring注解的类自动转化为Bean，同时完成Bean的注入  -->
        <context:component-scan base-package="com.book.dao"/>
        <context:component-scan base-package="com.book.service"/>

    <!--  定义一个数据库连接池的数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close"
          p:driverClassName="com.mysql.cj.jdbc.Driver"
          p:url="jdbc:mysql://localhost:3306/spring_book?useUnicode=true&amp;characterEncoding=UTF8"
            p:username="root"
          p:password="123456"/>
    <!-- JDBC模板Bean -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
          p:dataSource-ref="dataSource"/>

2、配置mybatis

db.properties：

#mysql jdbc
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/library?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

pom.xml

 <!--mybatis-spring适配器 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!-- mybatis ORM框架 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--jdbc连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.18</version>
        </dependency>
        <!--分页-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>

3、实现登录业务

先创建管理员实体类Admin和普通借阅用户实体类ReadCard
实现getter和setter方法

private long admin_id;
    private String password;
    private String username;

    public long getAdminId() {
        return admin_id;
    }

    public void setAdminId(long admin_id) {
        this.admin_id = admin_id;
    }

    public String getPassword() {
        return password;
    }

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

    public String getUsername() {
        return username;
    }

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

ReadCard的setter与getter此处省略，之后的也一样，只写对应的实体属性

	private long reader_id;
    private String username;
    private String password;

开始写Dao数据访问层接口和实现类：
接口：

public interface AdminDao {
    int getMatchCount(final long admin_id, final String password);
    int resetPassword(final long admin_id, final String password);
    String getPassword(final long admin_id);
    String getUsername(final long admin_id);
}

public interface ReaderCardDao {
    int getIdMatchCount(final long reader_id, final String password);
    ReaderCard findReaderByReaderId(final long reader_id);
    int resetPassword(final long reader_id, final String newPassword);
    int addReaderCard(final ReaderInfo readerInfo, final String password);
    String getPassword(final long reader_id);
    int deleteReaderCard(final long reader_id);
}

实现类：以AdminDao接口AdminDaoImpl为例

@Repository
public class AdminDaoImpl implements AdminDao {

    private final static String NAMESPACE = "com.book.dao.impl.AdminDaoImpl.";
    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    @Override
    public int getMatchCount(final long admin_id, final String password) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("admin_id", admin_id);
        paramMap.put("password", password);
        return sqlSessionTemplate.selectOne(NAMESPACE + "getMatchCount", paramMap);
    }

    @Override
    public int resetPassword(final long admin_id, final String password) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("admin_id", admin_id);
        paramMap.put("password", password);
        return sqlSessionTemplate.update(NAMESPACE + "resetPassword", paramMap);
    }

    @Override
    public String getPassword(final long admin_id) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "getPassword", admin_id);
    }

    @Override
    public String getUsername(final long admin_id) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "getUsername", admin_id);
    }

}

开始写Service服务层接口和实现类：
LoginService定义方法：

	boolean hasMatchReader(long readerId,String password);

    String getAdminUsername(long adminId);

    ReaderCard findReaderCardByReaderId(long readerId);

    boolean hasMatchAdmin(long adminId,String password);

    boolean adminRePassword(long adminId, String newPassword);

    String getAdminPassword(long adminId);

    boolean readerRePassword(long readerId, String newPassword);

    String getReaderPassword(long readerId);

对应的实现类写逻辑方法
注入数据交互，使得通过数据交互层对数据库进行访问，实现登录功能

@Service
public class LoginServiceImpl implements LoginService{

    @Autowired
    private ReaderCardDaoImpl readerCardDaoImpl;
    @Autowired
    private AdminDaoImpl adminDaoImpl;

    @Override
    public boolean hasMatchReader(long readerId, String password){
        return  readerCardDaoImpl.getIdMatchCount(readerId, password)>0;
    }

    @Override
    public String getAdminUsername(long adminId) {
        return adminDaoImpl.getUsername(adminId);
    }

    @Override
    public ReaderCard findReaderCardByReaderId(long readerId){
        return readerCardDaoImpl.findReaderByReaderId(readerId);
    }

    @Override
    public boolean hasMatchAdmin(long adminId, String password){
        return adminDaoImpl.getMatchCount(adminId, password) == 1;
    }

    @Override
    public boolean adminRePassword(long adminId, String newPassword){
        return adminDaoImpl.resetPassword(adminId,newPassword)>0;
    }
    @Override
    public String getAdminPassword(long adminId){
        return adminDaoImpl.getPassword(adminId);
    }

    @Override
    public boolean readerRePassword(long readerId, String newPassword) {
        return readerCardDaoImpl.resetPassword(readerId, newPassword) > 0;
    }

    @Override
    public String getReaderPassword(long readerId) {
        return readerCardDaoImpl.getPassword(readerId);
    }


}

4、管理员业务实现

（1）相关业务的实现

与登陆有关的业务

@Autowired
    private ReaderCardDaoImpl readerCardDaoImpl;
    @Autowired
    private AdminDaoImpl adminDaoImpl;

    @Override
    public boolean hasMatchReader(long readerId, String password){
        return  readerCardDaoImpl.getIdMatchCount(readerId, password)>0;
    }

    @Override
    public String getAdminUsername(long adminId) {
        return adminDaoImpl.getUsername(adminId);
    }

    @Override
    public ReaderCard findReaderCardByReaderId(long readerId){
        return readerCardDaoImpl.findReaderByReaderId(readerId);
    }

    @Override
    public boolean hasMatchAdmin(long adminId, String password){
        return adminDaoImpl.getMatchCount(adminId, password) == 1;
    }

    @Override
    public boolean adminRePassword(long adminId, String newPassword){
        return adminDaoImpl.resetPassword(adminId,newPassword)>0;
    }
    @Override
    public String getAdminPassword(long adminId){
        return adminDaoImpl.getPassword(adminId);
    }

    @Override
    public boolean readerRePassword(long readerId, String newPassword) {
        return readerCardDaoImpl.resetPassword(readerId, newPassword) > 0;
    }

    @Override
    public String getReaderPassword(long readerId) {
        return readerCardDaoImpl.getPassword(readerId);
    }

与图书相关的业务

@Autowired
    private BookDaoImpl bookDaoImpl;

    @Override
    public PageInfo<Book> queryBook(String searchWord,int pageNum,int pageSize) {
        //分页
        PageHelper.startPage(pageNum,pageSize);
        ArrayList<Book> list = bookDaoImpl.queryBook(searchWord);
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;

    }

    @Override
    public PageInfo<Book> getAllBooks(int pageNum,int pageSize) {
        //分页
        PageHelper.startPage(pageNum,pageSize);
        ArrayList<Book> list = bookDaoImpl.getAllBooks();
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public boolean matchBook(String searchWord) {
        return bookDaoImpl.matchBook(searchWord) > 0;
    }

    @Override
    public boolean addBook(Book book) {
        return bookDaoImpl.addBook(book) > 0;
    }

    @Override
    public Book getBook(Long bookId) {
        return bookDaoImpl.getBook(bookId);
    }

    @Override
    public boolean editBook(Book book) {
        return bookDaoImpl.editBook(book) > 0;
    }

    @Override
    public boolean deleteBook(Long bookId) {
        return bookDaoImpl.deleteBook(bookId) > 0;
    }

    @Override
    public ArrayList<Type> getAllTypes() {
        return bookDaoImpl.getAllTypes();
    }

    //通过book_id找对应类型  进而找出book_id 对应的 类号和分类名
    @Override
    public Type getTypesById(Long bookId) {
        return bookDaoImpl.getTypesById(bookId);
    }

（2）相关业务的数据操作

管理员登陆

private final static String NAMESPACE = "com.book.dao.impl.AdminDaoImpl.";
    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    @Override
    public int getMatchCount(final long admin_id, final String password) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("admin_id", admin_id);
        paramMap.put("password", password);
        return sqlSessionTemplate.selectOne(NAMESPACE + "getMatchCount", paramMap);
    }

    @Override
    public int resetPassword(final long admin_id, final String password) {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("admin_id", admin_id);
        paramMap.put("password", password);
        return sqlSessionTemplate.update(NAMESPACE + "resetPassword", paramMap);
    }

    @Override
    public String getPassword(final long admin_id) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "getPassword", admin_id);
    }

    @Override
    public String getUsername(final long admin_id) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "getUsername", admin_id);
    }

图书管理

private final static String NAMESPACE = "com.book.dao.impl.BookDaoImpl.";
    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    @Override
    public int matchBook(final String searchWord) {
        String search = "%" + searchWord + "%";
        return sqlSessionTemplate.selectOne(NAMESPACE + "matchBook", search);
    }

    @Override
    public ArrayList<Book> queryBook(final String searchWord) {
        String search = "%" + searchWord + "%";
        List<Book> result = sqlSessionTemplate.selectList(NAMESPACE + "queryBook", search);
        return (ArrayList<Book>) result;
    }

    @Override
    public ArrayList<Book> getAllBooks() {
        List<Book> result = sqlSessionTemplate.selectList(NAMESPACE + "getAllBooks");
        return (ArrayList<Book>) result;
    }

    @Override
    public int addBook(final Book book) {
        return sqlSessionTemplate.insert(NAMESPACE + "addBook", book);
    }

    @Override
    public Book getBook(final long bookId) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "getBook", bookId);
    }

    @Override
    public int editBook(final Book book) {
        return sqlSessionTemplate.update(NAMESPACE + "editBook", book);
    }

    @Override
    public int deleteBook(final long bookId) {
        return sqlSessionTemplate.delete(NAMESPACE + "deleteBook", bookId);
    }

    @Override
    public ArrayList<Type> getAllTypes() {
        List<Type> result = sqlSessionTemplate.selectList(NAMESPACE + "getAllTypes");
        return (ArrayList<Type>) result;
    }

    @Override
    public Type getTypesById(final long TypeId){
        return sqlSessionTemplate.selectOne(NAMESPACE + "getTypesById", TypeId);
    }

（3）mybatis数据库操作

admin.xml

<select id="getMatchCount" resultType="int">
        select count(*) from admin
        where admin_id = #{admin_id}
        and password = #{password}
    </select>
    <update id="resetPassword">
        update admin set password = #{password}
        where admin_id = #{admin_id}
    </update>
    <select id="getPassword" resultType="String" parameterType="long">
        select password from admin where admin_id = #{admin_id}
    </select>
    <select id="getUsername" resultType="String" parameterType="long">
        select username from admin where admin_id = #{admin_id}
    </select>

book.xml

<select id="getAllTypes" resultType="com.book.entity.Type">
        select * from class_info
    </select>
    <select id="getTypesById" resultType="com.book.entity.Type" parameterType="long">
        select c.class_id,c.class_name
        from book_info b inner join class_info c on b.class_id = c.class_id and b.book_id = #{book_id}
    </select>
    <insert id="addBook" parameterType="com.book.entity.Book">
        insert into book_info values
        (null, #{name}, #{author}, #{publish}, #{ISBN},
        #{introduction}, #{language}, #{price}, #{pub_date}, #{picture},
        #{class_id}, #{number})
    </insert>
    <update id="editBook" parameterType="com.book.entity.Book">
        update book_info set name=#{name}, author=#{author},
        publish=#{publish}, ISBN=#{ISBN}, introduction=#{introduction},
        language=#{language}, price=#{price}, pub_date=#{pub_date},picture=#{picture},
        class_id=#{class_id}, number=#{number} where book_id=#{book_id}
    </update>
    <select id="getAllBooks" resultType="com.book.entity.Book">
        select * from book_info
    </select>
    <select id="queryBook" resultType="com.book.entity.Book" parameterType="String">
        select * from book_info where name like #{search}
        or author like #{search} or introduction like #{search}
    </select>
    <select id="matchBook" resultType="int" parameterType="String">
        select count(*) from book_info where name like #{search}
        or author like #{search} or introduction like #{search}
    </select>
    <select id="getBook" resultType="com.book.entity.Book" parameterType="long">
        select * from book_info where book_id = #{book_id}
    </select>
    <delete id="deleteBook" parameterType="long">
        delete from book_info where book_id = #{book_id}
    </delete>

（4）相关业务的交互操作

登录业务的交互操作

//负责处理loginCheck.html请求
    //请求参数会根据参数名称默认契约自动绑定到相应方法的入参中
    @RequestMapping(value = "/api/loginCheck", method = RequestMethod.POST)
    public @ResponseBody
    Object loginCheck(HttpServletRequest request) {
        long id = Long.parseLong(request.getParameter("id"));
        String passwd = request.getParameter("passwd");
        boolean isReader = loginServiceImpl.hasMatchReader(id, passwd);
        boolean isAdmin = loginServiceImpl.hasMatchAdmin(id, passwd);
        HashMap<String, String> res = new HashMap<>();
        if (isAdmin) {
            Admin admin = new Admin();
            admin.setAdminId(id);
            admin.setPassword(passwd);
            String username = loginServiceImpl.getAdminUsername(id);
            admin.setUsername(username);
            request.getSession().setAttribute("admin", admin);
            res.put("stateCode", "1");
            res.put("msg", "管理员登陆成功！");
        } else if (isReader) {
            ReaderCard readerCard = loginServiceImpl.findReaderCardByReaderId(id);
            request.getSession().setAttribute("readercard", readerCard);
            res.put("stateCode", "2");
            res.put("msg", "读者登陆成功！");
        } else {
            res.put("stateCode", "0");
            res.put("msg", "账号或密码错误！");
        }
        return res;
    }

    @RequestMapping("/admin_main.html")
    public ModelAndView toAdminMain(HttpServletResponse response) {
        return new ModelAndView("admin_main");
    }

    @RequestMapping("/reader_main.html")
    public ModelAndView toReaderMain(HttpServletResponse response) {
        return new ModelAndView("reader_main");
    }

    @RequestMapping("/admin_repasswd.html")
    public ModelAndView reAdminPasswd() {
        return new ModelAndView("admin_repasswd");
    }

图书业务的交互操作

@RequestMapping("/querybook.html")
    public ModelAndView queryBookDo(String searchWord,@RequestParam(required = false,defaultValue = "1")int pageNum,@RequestParam(required = false,defaultValue = "10")int pageSize) {
        if (bookServiceImpl.matchBook(searchWord)) {
            PageInfo<Book> pageInfo = bookServiceImpl.queryBook(searchWord,pageNum,pageSize);
            ModelAndView modelAndView = new ModelAndView("admin_books");
            modelAndView.addObject("pageInfo", pageInfo);
            return modelAndView;
        } else {
            return new ModelAndView("admin_books", "error", "没有匹配的图书");
        }
    }

    @RequestMapping("/reader_querybook_do.html")
    public ModelAndView readerQueryBookDo(String searchWord,@RequestParam(required = false,defaultValue = "1")int pageNum,@RequestParam(required = false,defaultValue = "10")int pageSize) {
        if (bookServiceImpl.matchBook(searchWord)) {
            PageInfo<Book> pageInfo = bookServiceImpl.queryBook(searchWord,pageNum,pageSize);
            ModelAndView modelAndView = new ModelAndView("reader_books");
            modelAndView.addObject("pageInfo", pageInfo);
            return modelAndView;
        } else {
            return new ModelAndView("reader_books", "error", "没有匹配的图书");
        }
    }

    @RequestMapping("/admin_books.html")
    public ModelAndView adminBooks(@RequestParam(required = false,defaultValue = "1")int pageNum,@RequestParam(required = false,defaultValue = "10")int pageSize) {
        PageInfo<Book> pageInfo = bookServiceImpl.getAllBooks(pageNum,pageSize);
        ModelAndView modelAndView = new ModelAndView("admin_books");
        modelAndView.addObject("pageInfo", pageInfo);
        return modelAndView;
    }

    @RequestMapping("/book_add.html")
    public ModelAndView addBook() {
        ArrayList<Type> types = bookServiceImpl.getAllTypes();
        ModelAndView modelAndView = new ModelAndView("admin_book_add");
        modelAndView.addObject("types",types);
        return modelAndView;
    }

5、用户（读者）业务实现

（1）相关业务的实现

与借阅有关的业务

@Autowired
    private LendDaoImpl lendDaoImpl;

    @Override
    public boolean returnBook(long bookId, long readerId){
        return lendDaoImpl.returnBookOne(bookId, readerId)>0 && lendDaoImpl.returnBookTwo(bookId)>0;
    }

    @Override
    public boolean lendBook(long bookId, long readerId, String name){
        return lendDaoImpl.lendBookOne(bookId,readerId,name)>0 && lendDaoImpl.lendBookTwo(bookId)>0;
    }

    @Override
    public PageInfo<Lend> lendList(int pageNum,int pageSize){
        //分页
        PageHelper.startPage(pageNum,pageSize);
        ArrayList<Lend> list = lendDaoImpl.lendList();
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }
    @Override
    public PageInfo<Lend> myLendList(long readerId,int pageNum,int pageSize){
        //分页
        PageHelper.startPage(pageNum,pageSize);
        ArrayList<Lend> list = lendDaoImpl.myLendList(readerId);
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public int deleteLend(long serNum) {
        return lendDaoImpl.deleteLend(serNum);
    }

与读者有关的业务

@Autowired
    private ReaderInfoDaoImpl readerInfoDaoImpl;

    @Override
    public PageInfo<ReaderInfo> readerInfos(int pageNum,int pageSize) {
        //分页
        PageHelper.startPage(pageNum,pageSize);
        ArrayList<ReaderInfo> list = readerInfoDaoImpl.getAllReaderInfo();
        PageInfo pageInfo = new PageInfo(list);
        return pageInfo;
    }

    @Override
    public boolean deleteReaderInfo(long readerId) {
        return readerInfoDaoImpl.deleteReaderInfo(readerId) > 0;
    }

    @Override
    public ReaderInfo getReaderInfo(long readerId) {
        return readerInfoDaoImpl.findReaderInfoByReaderId(readerId);
    }

    @Override
    public boolean editReaderInfo(ReaderInfo readerInfo) {
        return readerInfoDaoImpl.editReaderInfo(readerInfo) > 0;
    }

    @Override
    public boolean editReaderCard(ReaderInfo readerInfo) {
        return readerInfoDaoImpl.editReaderCard(readerInfo) > 0;
    }

    @Override
    public long addReaderInfo(ReaderInfo readerInfo) {
        return readerInfoDaoImpl.addReaderInfo(readerInfo);
    }

（2）相关业务的数据操作

借阅图书

@Resource
    private SqlSessionTemplate sqlSessionTemplate;

    private final static String NAMESPACE = "com.book.dao.impl.LendDaoImpl.";

    @Override
    public int returnBookOne(final long book_id, long reader_id) {
        Map<String, Object> map = new HashMap<>();
        map.put("book_id", book_id);
        map.put("reader_id", reader_id);
        return sqlSessionTemplate.update(NAMESPACE + "returnBookOne", map);
    }

    @Override
    public int returnBookTwo(final long book_id) {
        return sqlSessionTemplate.update(NAMESPACE + "returnBookTwo", book_id);
    }

    @Override
    public int lendBookOne(final long book_id, final long reader_id,final String name) {
        Map<String, Object> map = new HashMap<>();
        map.put("book_id", book_id);
        map.put("reader_id", reader_id);
        map.put("name",name);
        return sqlSessionTemplate.insert(NAMESPACE + "lendBookOne", map);
    }

    @Override
    public int lendBookTwo(final long book_id) {
        return sqlSessionTemplate.update(NAMESPACE + "lendBookTwo", book_id);
    }

    @Override
    public ArrayList<Lend> lendList() {
        List<Lend> result = sqlSessionTemplate.selectList(NAMESPACE + "lendList");
        return (ArrayList<Lend>) result;
    }

    @Override
    public ArrayList<Lend> myLendList(final long reader_id) {
        List<Lend> result = sqlSessionTemplate.selectList(NAMESPACE + "myLendList", reader_id);
        return (ArrayList<Lend>) result;
    }

    @Override
    public int deleteLend(final long ser_num) {
        return sqlSessionTemplate.delete(NAMESPACE + "deleteLend", ser_num);
    }

读者信息管理

private final static String NAMESPACE = "com.book.dao.impl.ReaderInfoDaoImpl.";
    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    @Override
    public ArrayList<ReaderInfo> getAllReaderInfo() {
        List<ReaderInfo> result = sqlSessionTemplate.selectList(NAMESPACE + "getAllReaderInfo");
        return (ArrayList<ReaderInfo>) result;
    }

    @Override
    public ReaderInfo findReaderInfoByReaderId(final long reader_id) {
        return sqlSessionTemplate.selectOne(NAMESPACE + "findReaderInfoByReaderId", reader_id);
    }

    @Override
    public int deleteReaderInfo(final long reader_id) {
        return sqlSessionTemplate.delete(NAMESPACE + "deleteReaderInfo", reader_id);
    }

    @Override
    public int editReaderInfo(final ReaderInfo readerInfo) {
        return sqlSessionTemplate.update(NAMESPACE + "editReaderInfo", readerInfo);
    }

    @Override
    public int editReaderCard(final ReaderInfo readerInfo) {
        return sqlSessionTemplate.update(NAMESPACE + "editReaderCard", readerInfo);
    }

    @Override
    public final long addReaderInfo(final ReaderInfo readerInfo) {
        if (sqlSessionTemplate.insert(NAMESPACE + "addReaderInfo", readerInfo) > 0) {
            return sqlSessionTemplate.selectOne(NAMESPACE + "getReaderId", readerInfo);
        } else {
            return -1;
        }
    }

（3）mybatis数据库操作

lend.xml

<update id="returnBookOne">
        update lend_list set back_date = sysdate() where book_id = #{book_id}
        and reader_id = #{reader_id} and back_date is null
    </update>
    <update id="returnBookTwo" parameterType="long">
        update book_info set number = number + 1 where book_id = #{book_id}
    </update>
    <insert id="lendBookOne">
        insert into lend_list values
        (null , #{book_id} , #{reader_id} , sysdate() , null, #{name})
    </insert>
    <update id="lendBookTwo" parameterType="long">
        update book_info set number = number - 1 where book_id = #{book_id}
    </update>
    <select id="lendList" resultType="com.book.entity.Lend">
        select * from lend_list
    </select>
    <select id="myLendList" resultType="com.book.entity.Lend" parameterType="long">
        select * from lend_list where reader_id = #{reader_id}
    </select>
    <delete id="deleteLend" parameterType="long">
        delete from lend_list where ser_num = #{ser_num}
    </delete>

readerInfo.xml

<select id="getAllReaderInfo" resultType="com.book.entity.ReaderInfo">
        select * from reader_info
    </select>
    <select id="findReaderInfoByReaderId" resultType="com.book.entity.ReaderInfo" parameterType="long">
        select * from reader_info where reader_id = #{reader_id}
    </select>
    <delete id="deleteReaderInfo" parameterType="long">
        delete from reader_info where reader_id = #{reader_id}
    </delete>
    <update id="editReaderInfo" parameterType="com.book.entity.ReaderInfo">
        update reader_info set name = #{name} , sex = #{sex},
        birth = #{birth} ,address = #{address} ,phone = #{phone}
        where reader_id = #{reader_id}
    </update>
    <update id="editReaderCard" parameterType="com.book.entity.ReaderInfo">
        update reader_card set username = #{name}
        where reader_id = #{reader_id}
    </update>
    <insert id="addReaderInfo" parameterType="com.book.entity.ReaderInfo">
        insert into reader_info values
        (null, #{name},#{sex},#{birth},#{address},#{phone})
    </insert>
    <select id="getReaderId" resultType="long" parameterType="com.book.entity.ReaderInfo">
        select reader_id from reader_info where
        name = #{name} and sex = #{sex} and
        birth = #{birth} and address = #{address}
        and phone = #{phone}
    </select>

（4）相关业务的交互操作

借阅业务的交互操作

@Autowired
    private BookServiceImpl bookServiceImpl;

    @RequestMapping("/deletebook.html")
    public String deleteBook(HttpServletRequest request, RedirectAttributes redirectAttributes) {
        long bookId = Long.parseLong(request.getParameter("bookId"));
        if (bookServiceImpl.deleteBook(bookId)) {
            redirectAttributes.addFlashAttribute("succ", "图书删除成功！");
        } else {
            redirectAttributes.addFlashAttribute("error", "图书删除失败！");
        }
        return "redirect:/admin_books.html";
    }

    @RequestMapping("/lendlist.html")
    public ModelAndView lendList(HttpServletRequest request,@RequestParam(required = false,defaultValue = "1")int pageNum, @RequestParam(required = false,defaultValue = "10")int pageSize) {
        ModelAndView modelAndView = new ModelAndView("admin_lend_list");
        modelAndView.addObject("pageInfo", lendServiceImpl.lendList(pageNum,pageSize));
        return modelAndView;
    }

    @RequestMapping("/mylend.html")
    public ModelAndView myLend(HttpServletRequest request, @RequestParam(required = false,defaultValue = "1")int pageNum, @RequestParam(required = false,defaultValue = "10")int pageSize) {
        ReaderCard readerCard = (ReaderCard) request.getSession().getAttribute("readercard");
        ModelAndView modelAndView = new ModelAndView("reader_lend_list");
        modelAndView.addObject("pageInfo", lendServiceImpl.myLendList(readerCard.getReaderId(),pageNum,pageSize));
        return modelAndView;
    }

    @RequestMapping("/deletelend.html")
    public String deleteLend(HttpServletRequest request, RedirectAttributes redirectAttributes) {
        long serNum = Long.parseLong(request.getParameter("serNum"));
        if (lendServiceImpl.deleteLend(serNum) > 0) {
            redirectAttributes.addFlashAttribute("succ", "记录删除成功！");
        } else {
            redirectAttributes.addFlashAttribute("error", "记录删除失败！");
        }
        return "redirect:/lendlist.html";
    }

    @RequestMapping("/lendbook.html")
    public String bookLend(HttpServletRequest request, RedirectAttributes redirectAttributes) {
        long bookId = Long.parseLong(request.getParameter("bookId"));
        long readerId = ((ReaderCard) request.getSession().getAttribute("readercard")).getReaderId();
        String name = request.getParameter("name");
        if (lendServiceImpl.lendBook(bookId, readerId, name)) {
            redirectAttributes.addFlashAttribute("succ", "图书借阅成功！");
        } else {
            redirectAttributes.addFlashAttribute("succ", "图书借阅成功！");
        }
        return "redirect:/reader_books.html";
    }

读者业务的交互操作

@Autowired
    private ReaderInfoServiceImpl readerInfoServiceImpl;

    @Autowired
    private LoginServiceImpl loginServiceImpl;

    @Autowired
    private ReaderCardServiceImpl readerCardServiceImpl;

    private ReaderInfo getReaderInfo(long readerId, String name, String sex, String birth, String address, String phone) {
        ReaderInfo readerInfo = new ReaderInfo();
        Date date = new Date();
        try {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            date = df.parse(birth);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        readerInfo.setAddress(address);
        readerInfo.setName(name);
        readerInfo.setReaderId(readerId);
        readerInfo.setPhone(phone);
        readerInfo.setSex(sex);
        readerInfo.setBirth(date);
        return readerInfo;
    }

    @RequestMapping("allreaders.html")
    public ModelAndView allBooks(@RequestParam(required = false,defaultValue = "1")int pageNum,@RequestParam(required = false,defaultValue = "10")int pageSize) {
        PageInfo<ReaderInfo> pageInfo = readerInfoServiceImpl.readerInfos(pageNum,pageSize);
        ModelAndView modelAndView = new ModelAndView("admin_readers");
        modelAndView.addObject("pageInfo", pageInfo);
        return modelAndView;
    }

    @RequestMapping("reader_delete.html")
    public String readerDelete(HttpServletRequest request, RedirectAttributes redirectAttributes) {
        long readerId = Long.parseLong(request.getParameter("readerId"));
        if (readerInfoServiceImpl.deleteReaderInfo(readerId) && readerCardServiceImpl.deleteReaderCard(readerId)) {
            redirectAttributes.addFlashAttribute("succ", "删除成功！");
        } else {
            redirectAttributes.addFlashAttribute("error", "删除失败！");
        }
        return "redirect:/allreaders.html";
    }

    @RequestMapping("/reader_info.html")
    public ModelAndView toReaderInfo(HttpServletRequest request) {
        ReaderCard readerCard = (ReaderCard) request.getSession().getAttribute("readercard");
        ReaderInfo readerInfo = readerInfoServiceImpl.getReaderInfo(readerCard.getReaderId());
        ModelAndView modelAndView = new ModelAndView("reader_info");
        modelAndView.addObject("readerinfo", readerInfo);
        return modelAndView;
    }

    @RequestMapping("reader_edit.html")
    public ModelAndView readerInfoEdit(HttpServletRequest request) {
        long readerId = Long.parseLong(request.getParameter("readerId"));
        ReaderInfo readerInfo = readerInfoServiceImpl.getReaderInfo(readerId);
        ModelAndView modelAndView = new ModelAndView("admin_reader_edit");
        modelAndView.addObject("readerInfo", readerInfo);
        return modelAndView;
    }

    @RequestMapping("reader_edit_do.html")
    public String readerInfoEditDo(HttpServletRequest request, String name, String sex, String birth, String address, String phone, RedirectAttributes redirectAttributes) {
        long readerId = Long.parseLong(request.getParameter("readerId"));
        ReaderInfo readerInfo = getReaderInfo(readerId, name, sex, birth, address, phone);
        if (readerInfoServiceImpl.editReaderInfo(readerInfo) && readerInfoServiceImpl.editReaderCard(readerInfo)) {
            redirectAttributes.addFlashAttribute("succ", "读者信息修改成功！");
        } else {
            redirectAttributes.addFlashAttribute("error", "读者信息修改失败！");
        }
        return "redirect:/allreaders.html";
    }

    @RequestMapping("reader_add.html")
    public ModelAndView readerInfoAdd() {
        return new ModelAndView("admin_reader_add");
    }

    @RequestMapping("reader_add_do.html")
    public String readerInfoAddDo(String name, String sex, String birth, String address, String phone, String password, RedirectAttributes redirectAttributes) {
        ReaderInfo readerInfo = getReaderInfo(0, name, sex, birth, address, phone);
        long readerId = readerInfoServiceImpl.addReaderInfo(readerInfo);
        readerInfo.setReaderId(readerId);
        if (readerId > 0 && readerCardServiceImpl.addReaderCard(readerInfo, password)) {
            redirectAttributes.addFlashAttribute("succ", "添加读者信息成功！");
        } else {
            redirectAttributes.addFlashAttribute("succ", "添加读者信息失败！");
        }
        return "redirect:/allreaders.html";
    }

    @RequestMapping("reader_info_edit.html")
    public ModelAndView readerInfoEditReader(HttpServletRequest request) {
        ReaderCard readerCard = (ReaderCard) request.getSession().getAttribute("readercard");
        ReaderInfo readerInfo = readerInfoServiceImpl.getReaderInfo(readerCard.getReaderId());
        ModelAndView modelAndView = new ModelAndView("reader_info_edit");
        modelAndView.addObject("readerinfo", readerInfo);
        return modelAndView;
    }

    @RequestMapping("reader_edit_do_r.html")
    public String readerInfoEditDoReader(HttpServletRequest request, String name, String sex, String birth, String address, String phone, RedirectAttributes redirectAttributes) {
        ReaderCard readerCard = (ReaderCard) request.getSession().getAttribute("readercard");
        ReaderInfo readerInfo = getReaderInfo(readerCard.getReaderId(), name, sex, birth, address, phone);
        if (readerInfoServiceImpl.editReaderInfo(readerInfo) && readerInfoServiceImpl.editReaderCard(readerInfo)) {
            ReaderCard readerCardNew = loginServiceImpl.findReaderCardByReaderId(readerCard.getReaderId());
            request.getSession().setAttribute("readercard", readerCardNew);
            redirectAttributes.addFlashAttribute("succ", "信息修改成功！");
        } else {
            redirectAttributes.addFlashAttribute("error", "信息修改失败！");
        }
        return "redirect:/reader_info.html";
    }

那片世界那片海

关注

15
点赞
踩
69

收藏

觉得还不错? 一键收藏
7
评论
基于SpringMVC的图书管理系统

~本篇章将持续更新这也是本人经过Spring框架的学习，根据其他人项目的参考与改进，由此实现了一个较为基本的图书管理系统，也算是自己的一个学习经历吧，好了废话不多说，下面进入正题。文章目录一、项目概述功能性需求描述设计概述实现功能二、系统详细设计1、大框架的构建2、项目前期的准备工作总结一、项目概述功能性需求描述图书（馆）管理系统是典型的信息管理系统,其开发主要包括以下部分：后台数据库的建立、维护，前端应用程序的开发。对于前者，要建立起数据一致性和完整性强、数据安全性较好的数据库。而对于后
复制链接

扫一扫