idea+SSM框架实现简易书籍管理系统（超详细）

最新推荐文章于 2021-12-09 16:59:30 发布

WANTA_

最新推荐文章于 2021-12-09 16:59:30 发布

阅读量4.2k

点赞数 16

文章标签： ssm

本文链接：https://blog.csdn.net/ANJOOO/article/details/115611409

版权

简易书籍管理系统（SSM框架）

前言

一个用SSM框架实现的简易的书籍管理系统。首先统一一下开发环境，我们使用的是jdk1.8，mysql数据库。

一、环境搭建

1.建库建表

建立一个新的数据库，数据库名字就叫ssmbulid，数据库建立一张表books，表中有四个列名，分别是bookID，bookName，bookCounts，detail，如下图所示。
在这里插入图片描述

2.建立Maven项目，配置pom.xml文件

建立一个新项目，项目名称建议与表名对应叫ssmbuild
在这里插入图片描述

建立好项目后，开始配置pom.xml文件，将我们需要的依赖导入，这里没什么需要赘述的，需要什么依赖，导入就好，代码如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>ssmbuild</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <!-- spring版本号 -->
        <spring.version>5.1.9.RELEASE</spring.version>
        <!-- mybatis版本号 -->
        <mybatis.version>3.2.6</mybatis.version>
        <!-- log4j日志文件管理包版本 -->
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mybatis/spring包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
        <!-- 导入java ee jar 包 -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
        <!-- 导入Mysql数据库链接jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>
        <!-- JSTL标签类 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- 日志文件管理包 -->
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>


        <!-- 格式化对象，方便输出日志 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <!-- 映入JSON -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <!-- 上传组件包 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>


    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这里额外说一下这个依赖

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>

这个依赖会自动帮我们生成有参、无参构造、get()、set()方法不需要我们手动去编写，这个在下面的pojo类中会有详细的演示。

3.搭建web项目，配置Tomcat

点击File，点击Project Structure
在这里插入图片描述
点击Mouble，点击WebServices

点击Artifacts，点击WebApplication，选择第二个，Form Moudules，最后应用，这样web项目就搭建好了。

上述步骤结束后，大家会发现自己的项目多了一个web的文件夹

注意文件夹上面的那个小蓝点，只有拥有那个小蓝点，你的web项目才算搭建成功，如果没有小蓝点，就说明你的war包发布有问题，去找一个Artifacts那里。
接下来，我们来配置Tomcat
找到Run/Debug Configurations，点击+号，点击Tomcat Server，点击Local
在这里插入图片描述
点击Local后，选择Deployment，选择Artifact，导入之前搭建好的war包

这里导入本机电脑的Tomcat路径，到这里Tomcat就配置好了，可以开始正式的编写项目了。

二、编写配置文件

SSM框架是Spring+SpringMVC+Mybatis，所以我们的配置文件最好是分开成三个，这样逻辑较清晰，比较适合初学者以及对框架了解不是很好的使用者。
由于是项目的配置文件，除了web.xml，其他的关于整个项目的配置文件建议都放在resource里面，这样方便管理也易于修改。

1.配置持久层

标题首先编写spring-dao文件，看到dao我们就知道这个是Mybatis与Spring整合的文件
我们这里运用的数据库连接池是c3p0

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <!--1.关联数据库配置文件-->
        <context:property-placeholder location="classpath:database.properties"/>
<!--2.连接池
        dbcp:半自动化操作，不能自动连接
        c3p0:自动化操作，自动化的加载配置文件，并且可以自动设置到对象中
        druid:德鲁伊是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。
        hikari:SpringBoot的默认数据源
        -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!--c3p0连接池的私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭后不自动连接-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>
<!--3.sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--把数据源注入进来
         通过ref引用dataSource
            -->
    <property name="dataSource" ref="dataSource"/>
    <!--绑定MaBatis的配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
<!--配置Dao接口扫描包，运用反射，动态的实现了Dao接口可以注入到Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--扫描Dao-->
        <property name="basePackage" value="com.wang.dao"/>
    </bean>
</beans>

在resources文件夹下面建立文件datebase.propertise,这个文件的格式很固定，就是用来写数据的的数据的。
在这里插入图片描述
写好数据库文件后我们来连接数据库
在idea后面的工具中我们选择Database

点击Database后，选择Mysql

填写密码

点击Schemas，选择对应的数据库（刚刚建立的）

2.配置控制层、业务层

接下来我们要编写spring-mvc以及spring-service，顾名思义，这两个配置文件是Spring整合SpringMVC的配置文件
首先说spring-mvc.xml，我们知道ssm框架是靠SpringMVC实现前后端交互的，所以层级间的调用也是Controller（控制层）调用Service（业务层），Service（业务层）调用Dao（持久层），所以扫描Controller层的spring-mvc.xml代码如下。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--1.注解驱动-->
    <mvc:annotation-driven/>
    <!--2.静态资源过滤-->
    <mvc:default-servlet-handler/>
    <!--3.扫描包（controller）-->
    <context:component-scan base-package="com.wang.controller"/>
    <!--4.视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
<!--    包扫描-->
    <context:component-scan base-package="com.wang.controller"/>
</beans>

接着说spring-service.xml，理解了上面的spring-mvc.xml文件，这个spring-service.xml文件就很好理解了，没错这个就是用来配置扫描Service层的，具体代码如下。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--1.扫描service下的包-->
    <!--dao层与service层有两种关联方式，一种是使用import，另外一种是用idea把配置文件都放在一起-->
    <context:component-scan base-package="com.wang.service"/>
    <!--2.将所有的业务类，注入到Spring，可以通过配置或者注解实现-->
    <bean id="BookServiceImpl" class="com.wang.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>
    <!--声明式事务配置（自动提交）-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

最后一步，新建一个配置文件applicationContext.xml，将三个配置文件整合到这个文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <import resource="classpath:spring-dao.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>
</beans>

点开我们上文说的Project Structure再点击Module，我们可以看到如下的结构，这样看起来逻辑清晰，一目了然。
在这里插入图片描述

三、编写代码

1.pojo

建立一个pojo包，里面放实体类，这里面的pojo就相当于JavaBean
建立实体类Books，实体类名最好是与数据库表名相似，实体类的对象名最好与数据库的列名相同，方便编写，代码如下

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
}

这里运用了上文中说的lombok，只需要三个标签，就代替了有参、无参构造以及get、set方法，个人觉得使用标签比使用快捷键生成简单。

2.dao层

Dao层的实质就是对象与数据之间的映射，所以这一层在类的命名方式上面有着自己的特点。我们建立一个BookMapper接口，用来写CRUD的方法，具体代码如下：

mport com.wang.pojo.Books;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface BookMapper {
        int addBook(Books books);
        int deleteBook(@Param("bookID") int id);
        int updateBook(Books books);
        Books queryBookBYId(@Param("bookID") int id);
        List<Books> queryAllBook();
}

接下来建立一个Mapper.xml配置文件，这个配置文件里面主要用来编写数据库语句，也就是说BookMapper接口中方法操作数据库的对应的文件，代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace唯一定位-->
<!--实现了这个接口-->
<mapper namespace="com.wang.dao.BookMapper">
    <insert id="addBook" parameterType="Books">
       insert into ssmbuild.books (bookName, bookCounts, detail) 
       values (#{bookName},#{bookCounts},#{detail});
    </insert>
    <delete id="deleteBook" parameterType="int">
        delete from ssmbuild.books where bookID=#{bookID}
    </delete>
    <update id="updateBook" parameterType="Books">
        update ssmbuild.books set bookName=#{bookName} ,bookCounts=#{bookCounts},detail=#{detail}
         where bookID=#{bookID};
    </update>
    <select id="queryBookBYId" resultType="Books">
        select *from ssmbuild.books where bookID=#{bookID}
    </select>
    <select id="queryAllBook" resultType="Books">
        select * from ssmbuild.books
    </select>
</mapper>

如果在Dao层添加其他的功能，比如UserMapper接口，我们还需要针对这个接口写一个对应的数据库配置文件，但是我们是一个简单的系统，就不赘述那么多啦！

3.service层

Service层是用来调用Dao层的
我们要先建立一个BookService接口

package com.wang.service;
import com.wang.pojo.Books;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface BookService {
    int addBook(Books books);
    int deleteBook(int id);
    int updateBook(Books books);
    Books queryBookBYId(int id);
    List<Books> queryAllBook();
}

然后实现一下接口中的方法，建立一个BookService的实现类BookServiceImpl

package com.wang.service;

import com.wang.dao.BookMapper;
import com.wang.pojo.Books;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
//Service层调Dao层
@Service
public class BookServiceImpl implements BookService {
//    service调dao层：组合dao
    private BookMapper bookMapper;
//直接注入即可
    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    public int addBook(Books books) {
        return bookMapper.addBook(books);
    }

    public int deleteBook(int id) {
        return bookMapper.deleteBook(id);
    }

    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    public Books queryBookBYId(int id) {
        return bookMapper.queryBookBYId(id);
    }

    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }
}

在一些大型程序上，业务层其实是需要些一些业务逻辑的，而且这也是一个项目的关键，通常是不会让新手小白接触的······但是我们项目只是一个简易的管理系统，所以就只是调用了一下Dao层，emmmm，确实是有些拉胯······

4.controller层

controller层算得上是整个程序的核心，我们的业务逻辑都写在了这里，其实这一层很好理解，我们现在有了后端的数据库，controller层算是前后端交互的一个通道，这一层的代码写的也是比较有规律的。
我们首先创建一个类BookContyoller，实现CRUD等功能，传给前端页面，代码如下：

package com.wang.controller;

import com.wang.pojo.Books;
import com.wang.service.BookService;
import com.wang.service.BookServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/book")
public class BookController {
//    调service
@Autowired
@Qualifier("BookServiceImpl")
    private BookService bookService ;
//    查询全部的书籍，并且返回到书籍的展示页面

    @RequestMapping("/allBook")
    public String list(Model model){
        List<Books> list=bookService.queryAllBook();
        model.addAttribute("list",list);
        return "allBook";
    }
//    跳转到增加数据页面
    @RequestMapping("/toAddBook")
    public String toAddPaper(){
        return "addBook";
    }
//添加书籍的请求
    @RequestMapping("/addBook")
    public String addBook(Books books){
        bookService.addBook(books);
        return "redirect:/book/allBook";//重定向到@RequestMapping（"allBook"）请求
    }

    @RequestMapping("/toUpdateBook")
    public String toUpdateBook(Model model, int id) {
        Books books = bookService.queryBookBYId(id);
        System.out.println(books);
        model.addAttribute("book",books );
        return "updateBook";
    }

    @RequestMapping("/updateBook")
    public String updateBook(Model model, Books book) {
        System.out.println(book);
        bookService.updateBook(book);
        Books books = bookService.queryBookBYId(book.getBookID());
        model.addAttribute("books", books);
        return "redirect:/book/allBook";
    }
    @RequestMapping("/del/{bookId}")
    public String deleteBook(@PathVariable("bookId") int id) {
    bookService.deleteBook(id);
    return "redirect:/book/allBook";
    }
}

至此我们的后断代码就全部结束了，其实后端的代码都非常的有规律，因为许多事情都是框架的注解标签或者配置文件帮我们做了，我们要编写的代码都非常的有规律，大家只要勤加练习，就会掌握的。

5.前端界面

编写前端界面大家首先会想到什么呢？编写jsp？
不不不·····我们需要先写web.xml配置文件，其实前后端这里是有共通之处的。所谓工欲善其事必先利其器，把配置文件编写好，再来写代码会有事半功倍的效果。
web.xml其实就是要写一个响应请求以及一个过滤器，这个也是配置完之后不用再打开了的文件，很有规律，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--    DispatchServlet接管了所有请求-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
<!--    乱码过滤-->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
<!--Session过期时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

写好了web.xml之后，我们建立一个index.jsp文件，为我们的书籍管理系统做一个首页，当然了本人开发侧重后端较多，各位观众老爷不要嫌弃前端页面丑，我真的尽力了······

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE HTML>
<html>
<head>
       <title>首页</title>
       <style type="text/css">
           a {
         text-decoration: none;
         color: black;
          font-size: 18px;
        }
           h3 {
         width: 180px;
         height: 38px;
       margin: 100px auto;
        text-align: center;
         line-height: 38px;
         background: deepskyblue;
        border-radius: 4px;
       }
       </style>
</head>
<body>
<h3>
       <a href="${pageContext.request.contextPath}/book/allBook">点击进入列表页</a>
</h3>
</body>
</html>

做好一个首页后我们要开始我们的CRUD功能的页面，在web文件夹下面新建一个jsp文件夹，把我们的CRUD功能的页面放在这里，便于管理。
查询全部书籍

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
       <title>书籍列表</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <div class="page-header">
                   <h1>
                       <small>书籍列表 —— 显示所有书籍</small>
                   </h1>
               </div>
           </div>
       </div>
       <div class="row">
           <div class="col-md-4 column">
               <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增书籍 </a>
           </div>
       </div>
       <div class="row clearfix">
           <div class="col-md-12 column">
               <table class="table table-hover table-striped">
                   <thead>
               <tr>
                       <th>书籍编号</th>
                       <th>书籍名字</th>
                       <th>书籍数量</th>
                       <th>书籍详情</th>
                       <th>操作</th>
                   </tr>
               </thead>
                   <tbody>
                <%--书籍从数据库中查询出来，从这个list中遍历出来：foreach
                    var是book中的每一个值
                    --%>
               <c:forEach var="book" items="${requestScope.get('list')}">
                       <tr>
                           <td>${book.getBookID()}</td>
                           <td>${book.getBookName()}</td>
                           <td>${book.getBookCounts()}</td>
                           <td>${book.getDetail()}</td>
                           <td>
                               <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">更改</a> |
                               <a href="${pageContext.request.contextPath}/book/del/${book.getBookID()}">删除</a>
                           </td>
                       </tr>
                   </c:forEach>
               </tbody>
               </table>
           </div>
       </div>
</div>

增加书籍

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

<html>
<head>
       <title>新增书籍</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <div class="page-header">
                   <h1>
                       <small>新增书籍</small>
                   </h1>
               </div>
           </div>
       </div>
       <form action="${pageContext.request.contextPath}/book/addBook" method="post">
           书籍名称：<input type="text" name="bookName"><br><br><br>
           书籍数量：<input type="text" name="bookCounts"><br><br><br>
           书籍详情：<input type="text" name="detail"><br><br><br>
           <input type="submit" value="添加">
       </form>
</div>

修改、删除书籍

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
       <title>修改信息</title>
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
       <!-- 引入 Bootstrap -->
       <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
       <div class="row clearfix">
           <div class="col-md-12 column">
               <div class="page-header">
                   <h1>
                       <small>修改信息</small>
                   </h1>
               </div>
           </div>
       </div>
       <form action="${pageContext.request.contextPath}/book/updateBook" method="post">
           <input type="hidden" name="bookID" value="${book.getBookID()}"/>
           书籍名称：<input type="text" name="bookName" value="${book.getBookName()}"/>
           书籍数量：<input type="text" name="bookCounts" value="${book.getBookCounts()}"/>
           书籍详情：<input type="text" name="detail" value="${book.getDetail() }"/>
           <input type="submit" value="提交"/>
       </form>
</div>

前端的界面书写的方式非常的多，我们这里用了很简单的一种，如果大家有多余的时间可以把页面丰富一下。

补充（排错思路）

大家在开发过程中，可能会遇到很多bug，但是针对于用框架编写项目，bug的生产地多数是配置文件，这里给大家提供一些排错思路，欢迎补充交流哦~

1.Mapper.xml

这个配置文件最容易翻车的地方就是sql语句，建议大家把sql语句学好，这个真的很重要

2.web.xml

大家在配置web.xml的时候要注意路径问题,直接扫描applicationContext.xml这个配置文件即可，因为这个配置文件就包括了其他的三个配置文件

3.类、接口的常见问题

大家在写代码时一定要对应好对象名，不然就会报错，一定一定要注意大小写问题。

总结

这是一个简易的书籍管理系统，主要是帮助大家整合一下SSM框架，其实框架的代码非常的有规律，大家学习的时候不要单纯的学习框架，要学习的是框架的思想以及实现原理。

WANTA_

关注

16
点赞
踩
101

收藏

觉得还不错? 一键收藏
7
评论
idea+SSM框架实现简易书籍管理系统（超详细）

简易书籍管理系统（SSM框架）文章目录简易书籍管理系统（SSM框架）前言一、环境搭建1.建库建表2.建立Maven项目，配置pom.xml文件3.搭建web项目，配置Tomcat二、编写配置文件1.配置持久层前言一个用SSM框架实现的简易的书籍管理系统。首先统一一下开发环境，我们使用的是jdk1.8，mysql数据库。一、环境搭建1.建库建表建立一个新的数据库，数据库名字就叫ssmbulid，数据库建立一张表books，表中有四个列名，分别是bookID，bookName，bookCounts，
复制链接

扫一扫