SpringBoot搭建手册（最纯净起步）

SpringBoot最简单搭建

1 前期准备

1-1 环境准备

• 编译器：IDEA （后续以IDEA为例）
• jdk版本：jdk1.8
• 构建工具：Maven

1-2 创建新项目

第一步：打开IDEA,点击Create New Project，左侧选择Spring Initializer ，右侧分别配置JDK、项目名称、项目地址等。

第二步：选择起步依赖，后续按需添加。

1-3 配置文件

第一步：创建SpringBoot基础4层（controller、mapper、pojo、seriver)

1.controller层，控制层 控制业务逻辑

• controller层负责前后端交互，接受前端请求,实现具体的业务模块流程的控制。

• 调用service层，接收service层返回的数据，最后返回具体的页面和数据到客户端。

  注：1.往往定义一个service接口的对象，然后调用里面的方法，接着将结果输出即可。

​ 2.要加@Controller，该注解加在类上，配合@RequestMapping注解，可以在一个类中定义多个接口。@RequestMapping用来和http 请求进行交互。如需返回数据，要加上@ResponseBody，或将@Controller改为@RestController。

2.Service层, 业务层 控制业务

• Service层主要负责业务模块的逻辑应用设计。

• 先设计放接口的类，再创建实现的类（impl），然后在配置文件中进行配置其实现的关联。

• 调用mapper层，接收mapper层返回的数据，完成项目的基本功能设计。

  注：seirver层有利于解耦，封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。小项目中作用不显，可去除减少代码量。

3.mapper层，别名dao， 数据持久层 主要与数据库进行交互

• 会定义实际使用到的方法，比如增删改查。对数据进行持久化操作。

• 调用pojo层。

  注：要写上@mapper注解，告诉springboot这个是mapper接口。mapper层所定义的接口要实现对数据的操作可以采用两种方式：一个是加上@mapper注解之后，采用sql语句。另一种是继承mapper接口（extends mapper()<>)。

4.pojo层， 别名entity、model, 实体层 数据库在项目中的类

• 是数据库在项目中的类，包含实体类的属性和对应属性的set、get方法。

  注：在MySQL或者navicat中使用 desc 表名 查看表的结构。

其他重要！

​ 主要目录：

​ 1.src/main/java：程序开发以及主程序入口

​ 2.src/main/resources：配置文件

​ 3.src/test/java：测试程序

​ 主要文件：

​ 1 DemoApplication.java -项目唯一启动类（带有@SpringBootApplication 注解）

​ 2 static 存放web访问的静态资

​ 3 templates 存放模板文件

​ 4 application.properties 项目配置文件

​ 5 pom.xml 配置maven依赖的文件

第二步：在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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 所有的spring-boot工程都必须继承spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.example</groupId>
    <artifactId>JDBCdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>JDBCdemo</name>
    <description>JDBCdemo</description>

    <properties>
        <java.version>1.8</java.version>
        <thymeleaf-spring5.version>3.0.9.RELEASE</thymeleaf-spring5.version>
        <thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
    </properties>

    <dependencies>
    
        <!-- thymeleaf引入 页面模板技术，thymeleaf支持 th:text规则 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!-- web工程起步依赖 用于@RestController、@RequestMapping等注解-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- mybatis起步依赖 用于@Mapper 指定映射接口-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.4</version>
        </dependency>
        
        <!-- json引入 实现将Java对象转换为JSON格式等-->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.7</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.13.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.13.3</version>
        </dependency>
        
        <!-- MySQL连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- springboot继承的测试起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <!--  junit测试，创建项目时会自动引入该依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
        
        <!--  springboot热部署 -->
		<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-devtools</artifactId>
    		<optional>true</optional>
		</dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

第三步：在maven更新依赖

有时要重启IDEA生效。

第四步：在application.properties文件中配置启动端口、数据库连接

server.port=8088  //启动端口

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url= jdbc:mysql://localhost:3306/\
  zetong.w?\		//数据库名
  useUnicode=true\	//数据库的字符集为Unicode
  &characterEncoding=utf-8\				//编码规则为utf-8
  &allowPublicKeyRetrieval=true\		//允许客户端从服务器自动请求公钥，可能允许恶意代理执行MITM攻击，必须显式启用
  &useJDBCCompliantTimezoneShift=true\	//使JDBC符合时区转换
  &useLegacyDatetimeCode=false\			//关闭服务器和客户端之间的时区转换，主要用于web服务器和数据库部署在不同时区时
  &serverTimezone=UTC\		//设置数据库时区
  &useSSL=false				//自己测试可以使用useSSL=false关闭SSL，生产环境需要开启SSL
  //以上7行进行传递数据，注释、空格需删除 
      
    /*SSL协议作用：
      	1.认证用户服务器，确保数据发送到正确的服务器
      	2.加密数据，防止数据传输途中被窃取使用；
      	3.维护数据完整性，验证数据在传输过程中是否丢失；*/

spring.datasource.username= root		//数据库用户名
spring.datasource.password= 123456		//数据库密码

第五步：在项目名Application.java文件中配置启动

@ServletComponentScan	//进入filter(过滤器)，可选加
@SpringBootApplication
@MapperScan(value = "com.example.jdbcdemo.mapper")  // mybatis需要扫描mapper接口
public class jdbcDemoApplication extends WebMvcConfigurationSupport {

    public static void main(String[] args) {		//启动
        SpringApplication.run(jdbcDemoApplication.class, args);
    }

    @Override		//扫描src/main/resources/static路径下的静态文件如.css .png .jpg .js等
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
            .addResourceLocations(ResourceUtils.CLASSPATH_URL_PREFIX + "/static/");
        super.addResourceHandlers(registry);
    }

} //jdbcdemo需替换为自己的项目名

2 项目主体配置

2-1 数据库配置

cd ../bin  //进入mysql的bin目录
mysql -uroot -p密码

一、创建数据库：

CREATE DATABASE `数据库名`

二、创建数据表：

CREATE TABLE table_name (column_name column_type);

例:

三、一些sql语句（Navicat能可视化实现）

insert into  sql_sentence(id,name,password) values (#{id},#{name},#{password});  增

delete from sql_sentence where id= #{id};  删

update sql_sentence set name=#{name},password=#{password},email=#{email},permission=#{permission} 
where id=#{id};							改

select * from sql_sentence;		查（全部）

select * from sql_sentence where id= #{id};  查（特定）

select count(*) from manager where id= #{id} and password= #{password} ; 查（条数）

select username,managername,vistername 
from (user left join manager on user.id=manager.id) 
left join vister on user.id=vister.id;		（多表联查）

desc 表名;		显示结构

show tables;     显示所有表
show databases;  显示所有数据库

ALTER TABLE user ADD age INT(4);  新增字段

2-2 四层及页面示例

初级看这个

https://blog.youkuaiyun.com/weixin_43332628/article/details/103904406

所需数据库结构

2-3 filter(过滤器)

实现登录拦截，河蟹等功能

filter

@WebFilter(filterName = "FilterDemo01", urlPatterns = { "/*" })
public class LoginFilter implements Filter {
    @Resource
    ManagerService managerService;

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        String request_url = request.getRequestURI();
        if(     request_url.contains(".css") || request_url.contains(".js") ||
                request_url.contains(".png")|| request_url.contains(".do") ||
                request_url.contains(".jpg")
        ){
            //如果发现是css或者js文件，直接放行
            System.out.println("文件加载");
            chain.doFilter(request, response);
        }

        if(request_url.contains("/login")) {//如果访问login
            chain.doFilter(request, response);
            System.out.println("访问登录");
        }else {
            Integer userID = (Integer) request.getSession().getAttribute("id");
            String val = CookieUtil.getCookieValByKey("auto", request);
            if(userID==null) {
                if(val!= null&& !val.equals("")) {
                    int id = Integer.parseInt(val.split("_")[0]);
                    String pass = val.split("_")[1];
                    if(managerService.check(id, pass) > 0){
                        request.getSession().setAttribute("id", id);
                        chain.doFilter(request, response);
                    }else{
                        System.out.println("44444");
                        response.sendRedirect("http://192.168.1.85:8088/login");
                    }
                }else{
                    System.out.println("没有曾经记录");
                    response.sendRedirect("http://192.168.1.85:8088/login");
                }
            } else {
                chain.doFilter(request, response);
            }

        }
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
    }
}

controller

@RequestMapping("/login")
    public String login(Model model,HttpServletRequest req){
        model.addAttribute("Manager",new Manager());
        return "login";
    }

@RequestMapping("/loginCheck")
    @ResponseBody
    public int check(@ModelAttribute(value = "Manager") Manager manager,HttpServletRequest req, 				HttpServletResponse resp,Model model){
        //允许任何域名访问
        resp.setHeader("Access-Control-Allow-Origin","*");
        resp.setHeader("Access-Control-Allow-Headers","content-type");
        //允许任何方法post|get...
        resp.setHeader("Access-Control-Allow-Methods","POST,GET,DELETE,OPTIONS,PATCH");
        Integer managerId = manager.getId();
        String password = manager.getPassword();
        String auto = req.getParameter("auto");
        System.out.println(managerId);
        if(managerService.get(managerId)!=null) {
            if (managerService.check(managerId, password) > 0) {
                Cookie cookie;
                if(auto=="") {
                    cookie = new Cookie("auto", null);
                    System.out.println("no");
                }else {
                    cookie = new Cookie("auto", managerId + "_" + password);
                    System.out.println("ok");
                }
                cookie.setMaxAge(60*60);//cookie有效时间
                cookie.setPath("path=/");
                //设置路径，这个路径即该工程下都可以访问该cookie，否则只有设置该cookie路径及其子路径可以访问
                resp.addCookie(cookie);// 将Cookie添加到Response中,使之生效
                req.getSession().setAttribute("id", managerId);
                return 1;
            } else {
                return 0;
            }
        }
        else{
            return -1;
        }
    }

util

public class CookieUtil {

    public static String getCookieValByKey(String key,HttpServletRequest request) {

        String value = null;
        Cookie[] cookies = request.getCookies();
        if(cookies!= null && cookies.length>0) {
            for (Cookie cookie : cookies) {
                if(key.equals(cookie.getName())){
                    value = cookie.getValue();
                }
            }
        }
        return value;
    }
}

2-4 html参考