SpringBoot

一、xmind进行思维导图

二、Nginx

Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务。

Nginx是一款轻量级的Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，在BSD-like 协议下发行。其特点是占有内存少，并发能力强，事实上nginx的并发能力在同类型的网页服务器中表现较好，中国大陆使用nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等。

Nginx 是高性能的 HTTP 和反向代理的web服务器，处理高并发能力是十分强大的，能经受高负 载的考验,有报告表明能支持高达 50,000 个并发连接数。

Nginx支持热部署，启动简单，可以做到7*24不间断运行。几个月都不需要重新启动。

三、JavaWEB学习路线

JAVA WEB学习路线：

1. 先学存数据：mysql数据库
2. 接着学如何用java访问数据库：mybatis
3. 再学习前端，因为java访问的数据最终会展示在浏览器里面：html，css
4. 最终学习如何把第二步java获取到的数据展示前端：servlet、http（传输）、url
5. 发布web应用：spring、springMvc、SpringBoot

四、SpringBoot后端框架

（一）简介

SpringBoot是一个集成了Spring技术栈的一个大整合，是一个简化了Spring应用开发的框架，可以一站式解决J2EE的开发流程。

优点：

1.可以快速独立的创建Spring及主流框架集成的项目。

2.使用了嵌入式的Servlet容器,无需生成WAR包

3.在使用SpringBoot进行开发时可以使用Starts启动依赖，而SpringBoot会自动地把所需要的其他相关技术jar包导入.

4.大量的自动配置，极大地简化了我们的开发。

5.无需XML文件的大量编写,也不会生成代码，底层是利用SpringBoot写好的API来调用实现，开箱即用

6.SpringBoot也有运维监控项目的功能

7.SpringBoot与云计算的集成
虽然SpringBoot很大程度上简化了我们的开发，但是由于集成度很好，很难精通SpringBoot。

介绍一下单体应用：

把所有的应用需要的资源放到一个项目里面，即所有的功能都集中在单进程里面，那么可能我们的服务器运载能力较差，就需要用多个服务器来跑一个项目，那么这时就需要把整个项目复制到另外的服务器上，这就是单体应用。

微服务： 我们将各个功能模块分割出来为单独的功能元素，那么每个功能放在独自的服务上，那么每一个功能由于独立出来，我们在后面进行跨服务器分发这些服务的时候就可以有选择性组合（各功能的组合是通过http来实现的互联），而不需要像单体应用那样复制所有的功能。

（二）项目构建

企业级开发用到的项目构建工具有Maven，Gradle等，实训用到的项目构建工具是Maven。

Maven是一个轻量级的构建工具，免安装，使用的一般要遵从以下步骤：

1、确保JDK有效（我是jdk8改到jdk17）；

2、官网下载解压缩后，放在全英文路径下（否则之后会出错）；

3、配置Maven环境变量，并添加到path变量中；

4、新建本地仓库；

5、配置conf目录下的settings.xml，配置本地仓库以及镜像，不然导入依赖会很慢；

6、在idea中配置Maven；

7、在pom.xml中导入项目所需的依赖；

（三）项目技术

SpringBoot的观点是约定大于配置，通过约定好的机制可以帮助开发者避免繁琐的配置。与Spring、SpringMVC、Mybatis相比，SpringBoot的配置更加简洁，且内嵌Tomcat，启动也比较迅速。配置的方式有很多，比如：properties、yaml、xml、注解等方式。

SpringBoot是对Spring的改善和优化，它基于约定优化配置的思想，提供了大量的默认配置和实现。使用SpringBoot之后，程序员只需按照它规定的方式去进行代码的开发，而无须再去编写一堆复杂的配置。

SpringBoot的主要功能如下：

• 起步依赖：以功能化的方式将需要的依赖进行组合，通过以start的方式引入
• 默认配置：实现了大量框架的默认配置项，程序员无须再进行手动配置
• 内置Tomcat：SpringBoot开发的程序无需进行tomcat部署，可直接运行。

（四）配置

1、properties

基本语法：key=value

server.port=8083
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/tlias
spring.datasource.username=root
spring.datasource.password=root
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.mapper-locations=classpath*:mapper/*Mapper.xml
#??mtbatis?????
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

2、yaml配置

• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格
• 缩进的空格数不重要，只要相同层级的元素左对齐即可

server: 
	port: 8080 
spring: 
	datasource:
    url: jdbc:mysql://localhost:3306/mydatabase 
    username: your_username 
    password: your_password 
    driver-class-name: com.mysql.cj.jdbc.Driver 

3、xml配置

语义化的标签

<select ...>
</select>

4、注解

（五）注解

在Mybatis中，在mapper中通过注解写简单的sql语句

package com.qfnu.demo2.mapper;

import com.qfnu.demo2.entity.Dept;
import org.apache.ibatis.annotations.*;
import java.util.List;

@Mapper
public interface DeptMapper {
    @Select("select id,name,update_time from dept")
    List<Dept> queryAllDepts();
    @Select("select * from dept where name=#{name}")
    Dept selectDeptByName(@Param("name")String name);
    /**
     * mybatis可以使用参数绑定注解@param获取到java方法中的参数值
     * @param id
     * @param name
     * @return
     */
    @Update("update dept set name = #{name},update_time = now() where id = #{id}")
    int updateDept(@Param("id")int id,@Param("name") String name);

    @Insert("insert into dept(name,create_time,update_time) values (#{name},now(),now()")
    int insertDept(@Param("name") String name);

    @Delete("delete from dept where id = #{id}")
    int deleteById(@Param("id") int id);
}

@Mapper是Mybatis框架中的一个注解，用于标记接口或抽象类，并将其识别为Mybatis的映射器(Mapper)。

在MyBatis中，Mapper用于定义数据库操作的方法，可以通过Mapper与对应的XML文件或注解来执行SQL查询、更新等操作。

@Service是Spring框架中的注解之一，用于标记一个类作为服务层（Service Layer）组件。在典型的Spring应用程序中，服务层负责业务逻辑的处理，协调不同的数据操作，并提供给控制器（Controller）或其他部分所需的功能。

使用 @Service注解可以将一个类标识为Spring的服务组件（Java Bean），使得它可以被Spring容器自动扫描并进行实例化，同时可以通过依赖注入的方式在其他类中使用。

package com.qfnu.demo2.service.impl;

import com.qfnu.demo2.entity.Dept;
import com.qfnu.demo2.mapper.DeptMapper;
import com.qfnu.demo2.service.DeptService;
import com.qfnu.demo2.vo.Result;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Objects;
/*
* restful:representational transfer 描述状态转移*/
@Service
public class DeptServiceImpl implements DeptService {
    @Resource
    private DeptMapper deptMapper;
    @Override
   public List<Dept> queryAllDepts(){
        List<Dept> depts = deptMapper.queryAllDepts();
        return depts;
    }

    @Override
    public int updateDept(int id,String name){
        int i=deptMapper.updateDept(id,name);
        return i;
    }

    @Override
    public Result insertDept(String name) {
        Dept dept = deptMapper.selectDeptByName(name);
        if (Objects.nonNull(dept)) {
            return Result.error("部门名"+name+"重复");
        }
        int i = deptMapper.insertDept(name);
        return i>0?Result.success():Result.error("更新失败");
    }
    @Override
    public int deleteById(int id){
        return deptMapper.deleteById(id);
    }

}

在Spring框架中，有多个用于依赖注入的注解，它们用于告诉Spring容器如何注入依赖对象到目标类中。以下是一些常用的依赖注入注解：

1、@Autowired：最常用的依赖注入注解之一，可以用在构造函数、Setter方法、字段或者一般方法上。当Spring容器发现有一个需要依赖注入的地方，它会尝试在容器中寻找匹配的bean，并将其注入到目标位置。

@Service 
public class MyService { 
	private final MyRepository myRepository; 4 5 
	@Autowired 
	public MyService(MyRepository myRepository) { 
 		this.myRepository = myRepository;  
	}   
 	 //  Other  methods...  
  }  

2、@Qualifier：与@Autowired结合使用，当有多个匹配的bean时，@Qualifier
允许指定所需注入的具体bean名称。

 @Service  
  public  class  MyService  {  
  private  final  MyRepository  myRepository;  
  @Autowired  
  public MyService(@Qualifier("myRepositoryImpl")  
MyRepository  myRepository)  {  
  this.myRepository  =  myRepository;  
  }  
  
  //  Other  methods...  
  }  

3、@Resource：类似于@Autowired，可以用在字段、Setter方法或构造函数上，
允许通过名称来指定依赖对象，也可以指定bean名称。

 @Service 
public class MyService { 
    @Resource(name = "myRepositoryImpl")
    private MyRepository myRepository; 
    // Other methods... 
} 

4、@Inject：与@Autowired类似，也用于进行依赖注入。通常用在JSR-330标准下。

Spring容器扫描带有 @Controller注解的类，并将其注册为处理请求的控制器组件。在Web应用程序中，这些控制器负责路由不同的URL请求，并调用相应的业务逻辑以及视图渲染，将结果返回给用户。

在Spring框架中，用于标识控制器类及其方法的注解有很多，这些注解用于处理 HTTP请求和响应。以下是一些常用的在控制器（Controller）类中使用的注解：

1. @Controller：标识一个类为Spring MVC控制器，处理HTTP请求。通常用于类级别，用来标记控制器类。

2. @RestController：与@Controller类似，但是它将控制器类中的所有方法默认返回JSON或XML响应，而不是视图。通常用于RESTful风格的控制器。

3. @RequestMapping：用于将请求映射到控制器处理方法。它可以用在类级别和方法级别。可以指定请求的URL、HTTP方法、参数等。

4. @GetMapping、@PostMapping、@PutMapping、@DeleteMapping：这些注解用于将HTTP请求映射到相应的处理方法，分别对应GET、POST、PUT和 DELETE请求。

5. @RequestParam：用于从请求中获取单个参数值，可以指定参数名、默认值等。

6. @PathVariable：用于从请求URL中获取路径参数的值。

7. @RequestBody：用于将HTTP请求的body部分（通常是JSON或XML）映射到 Java对象。

8. @ResponseBody：用于将方法的返回值直接作为HTTP响应的body部分返回给客户端，通常用于RESTful控制器返回JSON或XML。

9. @ModelAttribute：用于将请求参数绑定到模型对象，通常用于将表单数据绑定到对象上。

10. @SessionAttributes：用于指定哪些模型属性需要存储在会话（session）中，通常用于跨请求共享数据。

    这些注解可以单独使用或结合在一起，帮助控制器类处理各种类型的HTTP请求，将请求映射到相应的处理方法，并处理请求参数、响应数据等。通过使用这些注解，可以更加方便地编写处理Web请求的控制器逻辑。

（六）Mapper.xml

在MyBatis中，执行数据库操作（增加、删除、修改、查询）通常通过定义 Mapper.xml中的SQL语句，然后使用MyBatis的SqlSession执行这些SQL语句。

例子：

<?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">

<mapper namespace="com.qfnu.demo2.mapper.EmpMapper">

    <!--更新员工-->
    <update id="update">
        update emp
        <set>
            <if test="username != null and username != ''">
                username = #{username},
            </if>
            <if test="password != null and password != ''">
                password = #{password},
            </if>
            <if test="name != null and name != ''">
                name = #{name},
            </if>
            <if test="gender != null">
                gender = #{gender},
            </if>
            <if test="image != null and image != ''">
                image = #{image},
            </if>
            <if test="job != null">
                job = #{job},
            </if>
            <if test="entrydate != null">
                entrydate = #{entrydate},
            </if>
            <if test="deptId != null">
                dept_id = #{deptId},
            </if>
            <if test="updateTime != null">
                update_time = #{updateTime}
            </if>
        </set>
        where id = #{id}
    </update>
	<!--删除员工-->
    <delete id="deleteByIds">
        delete from emp where id in
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
	<!--查询员工-->
    <select id="queryEmpsByPage" resultType="com.qfnu.demo2.entity.Emp">
        select id,name,image,gender,job,entrydate,update_time from emp
        <where>
            <if test="name != null and name != ''">
                name = #{name} and
            </if>
            <if test="gender > 0">
                and gender = #{gender} and
            </if>
            <if test="begin != null and begin!='' and end != null and end!=''">
                and entrydate between #{begin} and #{end}
            </if>
        </where>
    limit #{page},#{pageSize}
    </select>
</mapper>

解析：其中有动态SQL，在这个例子中，如果传入的参数name不为null，就会在SQL语句中加入AND name=#{name}。

（七）开发思想

IOC

IOC（Inversion of Control，控制反转）是一种软件设计原则，它是面向对象编程中的一个重要概念，也是许多现代框架（比如Spring）的基础。IOC的核心思想是将控制权从应用程序代码中转移给框架或容器，实现了对象之间的松耦合。
IOC的关键概念：

1. 控制反转： 传统的程序中，对象的创建和管理是由开发者手动进行的，而在IOC中，这种控制权被反转了，对象的创建和管理被委托给容器或框架，开发者只需要关注对象之间的依赖关系。
2. 依赖注入： 是IOC的一种实现方式，它是指容器负责将对象所需的依赖关系注入到对象中，使得对象能够解耦并能够更灵活地使用这些依赖。
3. 容器：IOC容器是用来管理对象的容器，它负责创建、配置和组装对象，以及管理它们的生命周期。Spring框架中的ApplicationContext就是一个经典的IOC容器。

（八）三层架构

在典型的Java Web应用中，通常会使用一种MVC（Model-View-Controller）的架构模式来组织代码，其中包括Mapper、Service和Controller这三个主要的组件：

（1）Mapper（数据访问层）：

作用： Mapper层主要负责与数据库交互，执行数据库操作（增加、删除、修改、查询）。

技术：通常使用ORM框架（例如MyBatis）来简化与数据库的交互，Mapper文件定义了与数据库相关的SQL映射和操作。

示例： Mapper文件中定义了数据库操作的SQL语句，负责数据的持久化和查询。

（2）Service（业务逻辑层）：

作用： Service层包含了应用程序的业务逻辑，封装了业务处理的方法和过程。

技术： 负责处理业务逻辑，调用Mapper层完成对数据的操作，并可能包含一些业务规则的实现。

示例： 实现了一些业务方法，对数据进行处理、逻辑判断，并调用Mapper层进行数据操作。

（3）Controller（表示层）：

作用： Controller层是应用程序的入口点，负责接收和处理用户请求，调用 Service层完成业务逻辑，并返回响应给用户。

技术： 接收HTTP请求，解析请求参数，调用Service层方法处理业务逻辑，并返回响应给客户端。

示例： 处理HTTP请求，解析请求参数，调用Service层的方法，将处理结果返回给客户端。

（九）交互关系：

通常情况下，Controller通过调用Service层的方法来处理业务逻辑，并可能将数据传递给前端视图（View），Service层则通过调用Mapper层来进行数据库操作。这种层次化的架构有助于代码的组织和维护，提高了代码的可读性和可维护性。
这种分层架构有助于解耦不同的组件，使得每个组件都可以专注于自己的责任范围，降低了代码的耦合度。

（十）VO

在软件开发中，VO（View Object，视图对象）是用于表示特定视图所需数据的对象。VO通常用于在不同层之间传递数据，尤其是在前端视图（View）与后端逻辑处理（Service、Controller）之间传递数据。
VO的作用：

1. 数据封装： VO负责将从数据库或服务层获取的数据按照视图的需求进行封装，以便于前端页面显示或其他处理。
2. 解耦合：在前后端交互时，VO可以将业务逻辑层和展示层（View）解耦，使得两者之间的数据传递更为清晰和简单。
3. 减少传输负担：可以仅传递前端需要的数据，避免过多不必要的数据传输，提高传输效率。

示例：
Result、PageVO

Result:
package com.qfnu.demo2.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Integer code;//响应码，1 代表成功; 0 代表失败
    private String msg;  //响应信息 描述字符串
    private Object data; //返回的数据

    //增删改 成功响应
    public static Result success(){
        return new Result(1,"success",null);
    }
    //查询 成功响应
    public static Result success(Object data){
        return new Result(1,"success",data);
    }
    //失败响应
    public static Result error(String msg){
        return new Result(0,msg,null);
    }
}
PageVo:
package com.qfnu.demo2.vo;

import lombok.Data;

import java.util.List;
@Data
public class PageVo<T> {
    /*
    * 总数
    * */
    private long total;
    /*
    * 分页数据
    * */
    private List<T> rows;

}

然后，在业务逻辑层或者Controller中，将User对象转换成UserVO对象，再传递给前端视图层进行展示。

优点：

定制性强： VO对象可以根据具体页面需求进行设计，灵活性较高。

简化传递： 可以减少不必要的数据传递，只传递前端需要的数据，提高效率。

保障数据安全性： 可以限制传递给前端的数据，避免敏感信息泄露。

VO在开发中常用于构建前后端之间的数据传递对象，帮助实现业务逻辑和界面展示的分离，提高代码的可维护性和灵活性。