Springboot的模块化使用

摘要：层级依赖的体现、实现基础增删查改、改善编程习惯、配置文件的改变、thymeleaf替代jsp、拦截器和过滤器

1、建立springboot父工程

artfactid:springbootDemo2---->由于要作为父工程，我们不再需要parent标签，有的话就删掉，再找到下面的标签，

加入<packaging>pom</packaging>

<groupId>com.aaa.liu.springboot</groupId>
    <artifactId>springbootDemo2</artifactId>
    <!--添加pom-->
    <packaging>pom</packaging>

    <version>1.0-SNAPSHOT</version>

 2、按照正常的流程开始在父工程的基础上新建module：springboot-mapper  springboot-model   springboot-service   springboot-web  springboot-common

再依次添加工程依赖，组成层次依赖的关系，，将所需要用到的jar包放入父工程的mxl中，并用dependencyManage管理：

<dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>1.5.22.RELEASE</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>1.5.22.RELEASE</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
                <version>1.5.22.RELEASE</version>
            </dependency>

            <dependency>
                <groupId>net.sourceforge.nekohtml</groupId>
                <artifactId>nekohtml</artifactId>
                <version>1.9.21</version>
            </dependency>

            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.0</version>
            </dependency>

            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

所有的子工程根据自身需要重写父工程中的依赖（不带版本号），有时可能会出现不带版本号的情况下不好使，那就带上，怎么好使怎么来！

注意：1.每次新建项目之后看一下setting中的maven路径是否正确，不正确的话及时更改！

　　　2.在添加依赖的时候时刻注意idea右侧maven模块中的dependency是否出现错误，如果出现错误，及时更换jar包或重写依赖！

　　　3.如果jar包下载下来了，但由于网速等原因，jar包不完整以至于出现错误，先将正在运行的项目停掉(不然jar包正在使用，无法删除)，注释掉依赖，去仓库中删除错误的jar包，

　　　再将依赖重写注释回来，让它重新下载!

3、在各个层分别写上基本的方法等，无论 是哪一个框架配置信息，全部都要写在web项目中，最终web项目是需要打包运行的，如果加载不到配置信息的情况下，则会报错！

4、配置springmvc的UTF-8编码集、配置springmvc的json格式化、配置springmvc的拦截器

　使用@SpringBootApplication注解，把创建出SpringMVCConfig标识成配置类

package com.aaa.liu.springboot.config;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import java.nio.charset.Charset;

/**
 * @Author 刘其佳
 * 2019/8/16 -- 21:36
 * @Version 1.0
 */

//使用SpringBooApplication注解将此类标识成配置类
@SpringBootApplication
public class SpringmvcConfig {

    /**
     * 配置springmvc的utf-8编码集处理
     * @return
     */
    @Bean
    public StringHttpMessageConverter stringHttpMessageConverter(){
        StringHttpMessageConverter converter=new StringHttpMessageConverter(Charset.forName("UTF-8"));
        return converter;
    }

    /**
     * 配置springmvc的json格式化
     * @return
     */
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter(){
        MappingJackson2HttpMessageConverter converter=new MappingJackson2HttpMessageConverter();
        converter.setPrettyPrint(true);
        return converter;
}
}

5、通过Mapper.xml的形式实现Mapper接口，需要在application.properties文件中进行配置mybatis

# 配置Tomcat
server.port=8081
server.context-path=/
# 配置数据源
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
spring.datasource.username=root
spring.datasource.password=123456
# 配置mybatis
# 给Mapper.xml需要返回的实体类取别名
mybatis.type-aliases-package=com.aaa.liu.springboot.model
# 配置mapper.xml的映射,支持通配符
mybatis.mapper-locations=classpath:mapper/*Mapper.xml

6、@MapperScan（“com.aaa.liu.springboot.mapper”）:配置注解扫描（配置过后，mapper层就不用再添加Mapper注解）

package com.aaa.liu.springboot;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author 刘其佳
 * 2019/8/16 -- 19:33
 * @Version 1.0
 */

@SpringBootApplication
@MapperScan("com.aaa.liu.springboot.mapper")
public class ApplicationRun {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationRun.class,args);
    }
}

7、在spring boot官网中很明确的表明，如果使用springboot作为架构的话，默认不支持jsp，如果非要使用jsp，可以手动加载配置，

实现js,  springboot默认支持thymeleaf模板，这个模板也是Java写的，使用非常方便，相当于jsp；

　　7.1.使用springboot支持thymeleaf模板的情况下，在开发阶段需要关闭thymeleaf的缓存，

　　　　在application.properties中进行配置：spring.thymeleaf.cache=false

　　7.2.添加thymeleaf的依赖：

　　　　springboot已将完整的把thymeleaf集成进框架中了，可以直接添加使用不需要任何配置信息

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
                <version>1.5.22.RELEASE</version>
            </dependency>

　　7..3.在springboot的官网描述如果使用thymeleaf作为HTML页面的情况下，默认springboot是在resources(classpath)下templates文件夹中进行加载创建templates文件夹

　　7.4.如果使用thymeleaf需要更换HTML头部信息

　<html lang="en">
            替换
            <html xmlns="http://www.w3.org/1999/xhtml"
              xmlns:th="http://www.thymeleaf.org"
              xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">

　　7.5.thymeleaf是一个非常严谨的模板，和普通的HTML不一样，需要严格按照HTML标准来实现，如果不按照HTML的标准就会报错;

　　　　且注意：<meta charset="utf-8">  是一个为闭合的标签。

　　　　如果觉得标准过于严格，也可以不遵循HTML标准化实现thymeleaf。

　　　　　　1、需要在application.properties文件中进行配置：

# 配置thymeleaf模板（不配置也可以，直接使用）
# 配置thymeleaf缓存：默认值true，需要手动修改为false
spring.thymeleaf.cache=false
# 配置不严谨的html
spring.thymeleaf.mode=LEGACYHTML5

　　　　　　2、需要导入jar包

<dependency>
                <groupId>net.sourceforge.nekohtml</groupId>
                <artifactId>nekohtml</artifactId>
                <version>1.9.21</version>
            </dependency>

7.6.thymeleaf的使用例子：

用户登录页面login.html——登录成功后查询数据并放入index.html页面——在页面上有增加、修改以及删除按钮：

login.html:

1 <!DOCTYPE html>
 2 <html xmlns="http://www.w3.org/1999/xhtml"
 3       xmlns:th="http://www.thymeleaf.org"
 4       xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
 5 <head>
 6     <meta charset="UTF-8">
 7     <title>Login</title>
 8 </head>
 9 <body>
10 <form action="login" method="post">
11     Username:<input type="text" name="username" /> <br />
12     Password:<input type="password" name="password" /> <br />
13     <input type="submit" value="Submit" />
14 </form>
15 </body>
16 </html>

index.html:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    <table border="1px solid black">
        <thead>
            <tr>
                <th>图书编号</th>
                <th>图书名称</th>
                <th>图书价格</th>
                <th>操作</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="book:${bookList}">
                <td th:text="${book.id}"></td>
                <td th:text="${book.bookName}"></td>
                <td th:text="${book.bookPrice}"></td>
                <td><a th:href="@{update(id=${book.id})}">修改</a> &nbsp;&nbsp;|&nbsp;&nbsp;<a th:href="@{deleteBook(id=${book.id})}">删除</a></td>
            </tr>
        </tbody>
    </table>
<a href="insert">添加</a>
</body>
</html>

insert.html:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
    <meta charset="UTF-8">
    <title>添加页面</title>
</head>
<body>
<form action="addBook" method="post">
<table>
    <tr>
        <td>书名</td>
        <td><input type="text" name="bookName" placeholder="请输入书名"/></td>
    </tr>
    <tr>
        <td>价格</td>
        <td><input type="text" name="bookPrice" placeholder="请输入价格"/></td>
    </tr>
    <tr>
        <td><input type="submit" value="Submit"/></td>
    </tr>
</table>
</form>
</body>
</html>

update.html:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
    <meta charset="UTF-8">
    <title>修改页面</title>
</head>
<body>
<form action="updateBook" method="post">
    <table>
        <tr>
            <td>编号</td>
            <td><input type="text" name="id" th:value="${bookId}"/></td>
        </tr>
        <tr>
            <td>书名</td>
            <td><input type="text" name="bookName" th:placeholder="${bookName}"/></td>
        </tr>
        <tr>
            <td>价格</td>
            <td><input type="text" name="bookPrice" th:placeholder="${bookPrice}"/></td>
        </tr>
        <tr>
            <td><input type="submit" value="Submit"/></td>
        </tr>
    </table>
</form>
</body>
</html>

404.html:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
    <meta charset="UTF-8">
    <title>404</title>
</head>
<body>
    <h1>This is 404 Page！！！！</h1>
</body>
</html>

controller：

package com.aaa.liu.springboot.controller;

import com.aaa.liu.springboot.model.Book;
import com.aaa.liu.springboot.model.User;
import com.aaa.liu.springboot.service.BookService;
import com.aaa.liu.springboot.service.UserService;
import com.aaa.liu.springboot.service.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;

/**
 * @Author 刘其佳
 * 2019/8/16 -- 23:43
 * @Version 1.0
 */
@Controller
public class LoginController {
    @Autowired
    private UserService userService;
    @Autowired
    private BookService bookService;

    /**
     * 跳转登录页面
     * @return
     */
    @RequestMapping("/")
    public String turnLoginPage(){
        return "login";
    }

    /**
     * 登陆方法：登录成功后重定向
     * @param user
     * @param request
     * @param model
     * @return
     */
    @RequestMapping("/login")
    public String login(User user, HttpServletRequest request, Model model){
        Map<String,Object> resultMap=userService.login(user,request);
        if(200==(Integer)resultMap.get("code")){
            User user1= (User) resultMap.get("result");
            model.addAttribute("user",user1);
            return "redirect:/turnIndexPage";
        }else {
            return "404";
        }
    }

    /**
     * 跳转至查询方法
     * @param modelMap
     * @return
     */
    @RequestMapping("/turnIndexPage")
    public String turnIndexPage(ModelMap modelMap){
        //需求是查询所有的图书信息
    Map<String,Object> resultMap=bookService.selectAll();
    List<Book> bookList= (List<Book>) resultMap.get("result");
    if(200==(Integer) resultMap.get("code")){
        modelMap.addAttribute("bookList",bookList);
        return "index";
    }
   return "404";
    }

    /**
     * 添加按钮跳转至添加页面
     * @return
     */
    @RequestMapping("/insert")
    public String insert(){
        return "insert";
    }
    /**
     * 进行添加图书
     * @param bookName
     * @param bookPrice
     * @return
     */
    @RequestMapping("/addBook")
    public String addBook(String bookName, Double bookPrice){
         Map<String,Object> resultMap=bookService.addBook(bookName,bookPrice);
         if(200==(Integer) resultMap.get("code")){
             return "redirect:/turnIndexPage";
            }
            return "404";
    }

    /**
     * 执行修改操作，并返回查询页面
     * @param id
     * @param model
     * @return
     */
    @RequestMapping("/update")
    public String update( Integer id,Model model){
        //根据id进行查询，并将数据放入修改页面table中
        Map<String, Object> resultMap = bookService.selectById(id);
        List<Book> bookList= (List<Book>) resultMap.get("result");
        if(200==(Integer) resultMap.get("code")){
            Book book = bookList.get(0);
            int bookId=book.getId();
            String bookName = book.getBookName();
            Double bookPrice = book.getBookPrice();
            model.addAttribute("bookId",bookId);
            model.addAttribute("bookName",bookName);
            model.addAttribute("bookPrice",bookPrice);
            return "update";
        }
        return "404";
    }

    /**
     * 删除
     * @param id
     * @param bookName
     * @param bookPrice
     * @return
     */
    @RequestMapping("/updateBook")
    public String updateBook(Integer id,String bookName,Double bookPrice){
        Book book=new Book(id,bookName,bookPrice);
        System.out.println(book);
        Map<String, Object> resultMap = bookService.updateBook(book);
        if(200==(Integer) resultMap.get("code")){
            return "redirect:/turnIndexPage";
        }else {
            return "404";
        }
    }

    /**
     * 执行删除，并返回删除页面
     * @param id
     * @return
     */
    @RequestMapping("/deleteBook")
    public String deleteBook(Integer id){
        Map<String, Object> resultMap = bookService.deleteBook(id);
        if(200==(Integer)resultMap.get("code")){
            return "redirect:/turnIndexPage";
        }else {
            return "404";
        }
    }
}

拦截器的配置：在web工程下创建一个interceptor包：

package com.aaa.liu.springboot.interceptor;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Author 刘其佳
 * 2019/8/16 -- 22:06
 * @Version 1.0
 */

@SpringBootApplication
public class LoginInterceptor extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加自定义的拦截器，并添加路径
        registry.addInterceptor(loginInterceptor()).addPathPatterns("/**");
    }

    //在类的内部自定义拦截器
    private HandlerInterceptor loginInterceptor(){
        //实例化接口
        HandlerInterceptor handlerInterceptor=new HandlerInterceptor() {
            public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
                System.out.println("我是拦截器，我被访问了！！！");
                return true;
            }

            public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

            }

            public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

            }
        };
        return handlerInterceptor;//将拦截器扔出
    }
}