springStudy

springStudy

。非侵入式:使用Spring Framework开发应用程序时，Spring对应用程序本身的结构影响非常小。对领域模型可以做到零污染;对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于Spring Framework开发应用程序时结构清晰、简洁优雅。

。控制反转:l0C–Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。

。随向切面编程:AOP–Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。

。容器:SpringIOC是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。

。组件化:Spring实现了使用简单的组件配置组合成一个复杂的应用。在Spring中可以使用XML和」Java注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不素的搭建超大型复杂应用系统。

。声明式:很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。

。一站式:在I0C和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在Spring Framework的基础上全部使用Spring来实现。

springBoot

1.SpringBoot在创建项目时，使用jar的打包方式。

2.SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。

3.使用SpringBoot和Spring构建的项目，业务代码逻辑编写方式完全一样。

运行代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BtaZgZwO-1667477141433)(C:\Users\30500\AppData\Roaming\Typora\typora-user-images\1666954613014.png)]访问成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8GrKDdvD-1667477141435)(C:\Users\30500\AppData\Roaming\Typora\typora-user-images\1666954343287.png)]

SpringBoot起步依赖原理分析

1.在spring-boot-starter-parent中定义了各种技术和版本信息，组合了一套最优搭配的技术版本

2.在各种starte中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。

3.我们的工程继承parent，引入starte后，通过依赖传递，就可以简单方便获取需要的jar包，并且不会存在版本冲突问题。

spring配置文件

application.properties

application.yaml

application.yml

当三个文件同时存在时，且在同一级目录，优先级最高的是properties，其次是yml，最后是yaml

Springboot中yaml语法严格

YAML文件以数据为核心的，比传统的xml方式更加简洁

YAML文件的扩展名可以是.yml或者.yaml

注意：port中间有个空格（port： 8080）

yaml

基本语法：

​ 1.大小写敏感

​ 2.数据值前边必须有空格，作为分隔符

​ 3.使用空格缩进表示层级关系，相同缩进表示同一级

数据格式：

​ 1.对象

​ 2.数组：使用“-”表示数组每个元素

​ 3.存量

参数引用：

​ 1.${key}

读取配置文件

读取配置有三种方式

1.@Value（适合单个读取语句多，且需要多个value,一个属性值比较方便

2.Environment（适合大量的，只需要env.getproPerty

3.@ConfigurationPeoperties

profile

1.profile配置方式

​ 多profile文件方式

​ YML多文档方式

2.profile激活方式

​ 配置文件

​ 虚拟机参数

​ 命令行参数

（1）profiles是用来完成不同环境下，配置动态切换功能的

（2）profiles配置方式

​ 多profile文件方式：提供多个配置文件，每个代表一种环境

​ 1.application-dev.properties/yml开发环境

​ 2.application-test.properties/yml开发环境

​ 3.application-pro.properties/yml开发环境

​ yml多文档方式：

​ 1.在yml中使用 — 分隔不同配置(三个短线，一个都不能少不能多)

（3）profiles激活方式

​ 1.配置文件：在配置文件中配置：spring.profiles.active=dev

​ 2.虚拟机参数：在VM option指定：-Dspring.profiles.active=dev

​ 3.命令行参数：java -jar xxx.jar --spring.profiles.active=dev

内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：

​ （1）file： ./config/:当前项目下的/config目录下

​ （2）file: ./ :当前项目的根目录

​ （3）classpath：/config/ ：classpath的/config目录

​ （4）classpath： / ：classpath的根目录

加载顺序为排列顺序，高优先级配置的属性会生效

Spring JDBCTemplate中的RowMapper使用

SpringBoot整合Junit

•  package com.itheima.springboottest;
   import org.springframework.stereotype.Service;
   /*
   
   - @Author: jun
   
   - @Date:2022/10/29 19:25
   
   - @概述：
     */
     @Service
     public class UserService {
     public void add(){
         System.out.println("add");
     }
   
     public void delete(){
         System.out.println("delete");
     }
     }
  

(JS中的var可以定义所有的数据类型，typeof查看数据类型)

用户服务类UserService，现在在test包中编写UserServiceTest测试类

package com.itheima.test;

/*

- @Author: jun
- @Date:2022/10/29 19:26
- @概述：
  */

import com.itheima.springboottest.SpringbootTestApplication;
import com.itheima.springboottest.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**

- userserivce的测试类
  */
  @RunWith(SpringRunner.class)
  @SpringBootTest(classes = SpringbootTestApplication.class)
  public class UserServiceTest {
  @Autowired
  private UserService userService;
  @Test
  public void testAdd(){
      userService.add();
  }

  @Test
  public void testDelete(){
      userService.delete();
  }

}

spring图书简单CRU功能实现（实例操作：待完成。。）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jOrsXCQM-1667477141435)(C:\Users\30500\AppData\Roaming\Typora\typora-user-images\1667054752243.png)]

springboot

mybatis+Thymeleaf

使用JDBC连接MySQL时，出现以下错误（enummm，一个连接问题真的卡了好久~~）：
Loading class com.mysql.jdbc.Driver’. This is deprecated. The new driver class iscom.mysql.cj.jdbc.Driver’. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

问题所在：在查阅相关资料之后，得知是由于jdbc驱动包名引发的问题
5.x版本的驱动文件jar包对应的是：
Class.forName(“com.mysql.jdbc.Driver”);
语句来加载数据库驱动

而我使用的是8.0x版本的数据库驱动文件，对此，需要将加载数据库驱动的语句更改为：
Class.forName(“com.mysql.cj.jdbc.Driver”);

除此之外：
url的设置也得进行修改，原本的url如下：
String ur=“jdbc:mysql://127.0.0.1:3306/student”;

应修改为如下：String url=“jdbc:mysql://127.0.0.1:3306/student?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8”;

其中student是数据库名

8.0x是不需要建立ssl连接的，你需要显示关闭，即url中的&useSSL=false；
serverTimezone=GMT%2B8"是进行时区的设置`

再给一个url样例如下：
Url="jdbc:mysql://localhost:3306/db3?useSSL=false&serverTimezone=Hongkong&characterEncoding=utf-8&

autoReconnect=true";

url基本格式如下:
连接地址+ssl连接关闭+字符集为utf-8+时区设置

2.Duplicate entry ‘0’ for key 'PRIMARY’的一种解决办法

解决办法时，把id字段设置为自增类型，相关SQL语句是：

create table t_user( id int primary key auto_increment ) 

User类型找不到的解决办法

resultType="com.jun.springbootbook.entity.User

或者在User实体类中添加

@Alias("User")

是

Store商城(10天搞定)

某一模块的开发

1. 持久层开发：依据前端页面的设置规划相关的SQL语句了，以及进行配置
2. 业务层开发：核心功能控制、业务操作以及异常的处理
3. 控制层开发：接收请求、处理响应
4. 前端开发：JS、Query、AJAX这些技术来连接后台

搭建项目

1.jdk 1.8

2.maven:配置到3.61

3.数据库：MariaDB、Mysql，5.1及以上

4.项目名称：store，商城

5.结构：com.cy.store

6.资源：resources文件夹（static、templates）

7.单元测试：test.com.cy.store

这里用老师的是错误的，改为自己的

spring.datasource.url=jdbc:mysql://localhost:3306/store?serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=123456

8.访问项目的静态资源是否可以正常的加载

（1）用户注册

通过MyBatis来操作数据库，在做mybatis开发的流程。

注册-持久层

1.规划需要执行的SQL语句

1.用户的注册功能，相当于在做数据的插入操作

insert into t_user （username，password） value（值列表）

2.在用户的注册时首先要查询当前的用户名是否存在，如果存在则不能进行注册。相当于是一条查询语句。（创建一个UserMapper的接口。要在接口中定义这两个SQL语句抽象方法。

select * from t_user where username=?

（一定是先规划语句，然后再想代码怎么写）

2.设计接口和抽象方法

定义Mapper接口，在项目的目录结构下首先创建一个mapper包，在这个包下在再根据不同的功能模块来创建mapper接口，创建一个UserMapper的接口。

package com.cy.store.mapper;


import com.cy.store.entiy.User;

/**
 *用户模块的持久层接口
 */
//@Mapper这种写法不建议使用，一个项目当中会有很多个mapper接口，很麻烦，所有我们采用在启动类里添加Mapper的路径，让SpringBoot知道你的mapper在哪
public interface UserMapper {
    /**
     * 插入用户的数据
     * @param user  用户的数据
     * @return  受影响的行数（增、删、改，都受影响的行数作为返回值，可根据返回值来判断是否执行成功
     */
    //插入的操作，建议用Integer作为返回值，影响的行数来判断是否存在，注：这里字段太多，建议生成对象的形式，即User用户对象
    Integer insert(User user);


    /**
     * 根据用户名来查询用户的数据
     * @param username  用户名
     * @return  如果找到对应的用户则返回这个用户的数据，如果没有找到则返回NULL值
     */
    User findByUsername(String username);

}

3.编写映射

1.定义xml映射文件，与对应的接口进行关联。所有的映射文件需要防止resource目录下，在这个目录下创建一个mapper文件夹，然后在这个文件夹下存放Mapper的映射文件。

2.创建一个接口对应的映射文件，遵循和接口的名称保持一致即可。创建一个UserMapper.xml文件。

<?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.cy.store.mapper.UserMapper">

</mapper>

3.配置接口中的方法对应上的SQL语句上，需要借助标签来完成，insert\update\delete\select,对应的是SQL语句的增删改查操作。

4.单元测试：每个独立的层编写完毕后需要编写单元测试，来测试当前的功能，在test包结构下创建一个mapper包，在这个包下在创建持久层的功能测试

5.在测试的过程中发现有一个错误一直出现， 最后发现在实体类的基类中，createdUser我写成了createUser，少了一个d就导致后面一直找不到createdUser在User实体类中。

注册-业务层

规划异常

1. RuntimeException异常，作为异常的子类，然后再去定义具体的异常类型来继承这个异常。业务层异常的基类，ServeiceException异常。这个异常继承RuntimeException异常，异常机制的建立。

   package com.cy.store.service.ex;
   
   /*
    * @Author: jun
    * @Date:2022/11/1 14:23
    * @概述：
    */
   
   /**
    * 业务层异常的基类：throws new ServiceException("业务层产生未知的异常")
    */
   public class ServiceException extends RuntimeException{
       public ServiceException() {
           super();
       }
   
       //常用
       public ServiceException(String message) {
           super(message);
       }
       //常用
       public ServiceException(String message, Throwable cause) {
           super(message, cause);
       }
   
       public ServiceException(Throwable cause) {
           super(cause);
       }
   
       protected ServiceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
           super(message, cause, enableSuppression, writableStackTrace);
       }
   }
   
   

   根据业务层不同的功能来详细的定义具体的异常的类型，然后统一的去继承ServiceException异常类。

2. 用户在进行注册时可能会产生用户名被占用的错误，抛出一个异常：

   用户名被占用：UsernameDuplitedException异常。

   package com.cy.store.service.ex;
   
   /*
    * @Author: jun
    * @Date:2022/11/1 15:32
    * @概述：
    */
   /**用户名被占用异常**/
   public class UsernameDuplicatedException extends ServiceException {
       public UsernameDuplicatedException() {
           super();
       }
   
       public UsernameDuplicatedException(String message) {
           super(message);
       }
   
       public UsernameDuplicatedException(String message, Throwable cause) {
           super(message, cause);
       }
   
       public UsernameDuplicatedException(Throwable cause) {
           super(cause);
       }
   
       protected UsernameDuplicatedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
           super(message, cause, enableSuppression, writableStackTrace);
       }
   }
   
   

3. 正在执行数据插入操作的时候，服务器、数据库宕机。处于正在执行插入的过程中所产生的异常

   package com.cy.store.service.ex;
   
   /*
    * @Author: jun
    * @Date:2022/11/1 15:35
    * @概述：
    */
   
   /**
    * 数据在插入的过程中所产生的异常
    */
   public class InsertException extends ServiceException{
       public InsertException() {
           super();
       }
   
       public InsertException(String message) {
           super(message);
       }
   
       public InsertException(String message, Throwable cause) {
           super(message, cause);
       }
   
       public InsertException(Throwable cause) {
           super(cause);
       }
   
       protected InsertException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
           super(message, cause, enableSuppression, writableStackTrace);
       }
   }
   
   

   设计接口和抽象方法

在service包下创建了一个UserService接口

package com.cy.store.service;

import com.cy.store.entity.User;

/**
 * 用户模块业务层接口
 */
public interface IUserService {
    /**
     * 用户注册方法
     * @param user  用户的额数据对象
     */
    void reg(User user);
}

创建一个实现类UserServicempl类，需要实现这个接口，并且实现抽象方法

然后在单元测试

注册-控制层

创建响应

状态码、状态描述信息、数据。这部分功能封装到一个类中，将这类作为方法放回值，返回给前端浏览器。

package com.cy.store.util;

import java.io.Serializable;

/*
 * @Author: jun
 * @Date:2022/11/2 10:08
 * @概述：
 */

/**
 * Json格式的数据进行响应
 * @param <E>
 */
public class JsonResult<E> implements Serializable {
    /**
     * 状态码
     */
    private Integer state;
    /**
     * 描述信息
     */
    private String message;
    /**
     * 数据，不知道类型就泛型描述
     */
    private E date;

    public JsonResult() {
    }

    //捕获异常
    public JsonResult(Throwable e) {
        this.message = e.getMessage();
    }

    public JsonResult(Integer state, E date) {
        this.state = state;
        this.date = date;
    }
    
    //再将get和set方法声明出来

    public Integer getState() {
        return state;
    }

    public void setState(Integer state) {
        this.state = state;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public E getDate() {
        return date;
    }

    public void setDate(E date) {
        this.date = date;
    }
}

设计请求

依据当前的业务功能模块进行请求的设计

请求路径：/users/reg

请求参数：User user

请求类型：POST

响应结果：JsonResult

处理请求

1.创建一个控制层对应的类UserController类。依赖于业务层的接口。

package com.cy.store.controller;

import com.cy.store.entity.User;
import com.cy.store.service.IUserService;
import com.cy.store.service.ex.InsertException;
import com.cy.store.service.ex.UsernameDuplicatedException;
import com.cy.store.util.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/*
 * @Author: jun
 * @Date:2022/11/2 10:47
 * @概述：
 */
//@Controller
@RestController //这个注解的功能等效于@Controller+@ResponseBody
@RequestMapping("users")
public class UserController {
    @Autowired
    private IUserService userService;

    @RequestMapping("reg")
//    @ResponseBody   //表示此方法的响应结果以json格式进行数据的响应给到前端，比较麻烦
    public JsonResult<Object> reg(User user){
        //创建响应返回的结果对象
        JsonResult<Object> jsonResult = new JsonResult<>();
        try {
            userService.reg(user);
            jsonResult.setState(200);   //注册成功状态码为200
            jsonResult.setMessage("用户注册成功");    //提示成功
        } catch (UsernameDuplicatedException e) {
            jsonResult.setState(4000);  //当用户名被占用时，设置状态码为4000
            jsonResult.setMessage("用户名被占用");    //设置描述信息
        } catch (InsertException e){
            jsonResult.setState(5000);    //插入数据异常,设置状态码为5000
            jsonResult.setMessage("注册时产生未知的异常");
        }
        return jsonResult;
    }
}

以上代码业务逻辑比较繁琐，每一层的异常都要重新写一份捕获异常。所以我们用另一种方法来实现。如下：

控制层优化设计

在控制层抽离一个父类，在这个父类中统一的去处理关于异常的相关操作。故需要编写一个BaseController类，统一处理异常。（用继承思想实现捕获异常的方法）

package com.cy.store.controller;

/*
 * @Author: jun
 * @Date:2022/11/2 11:15
 * @概述：
 */

import com.cy.store.service.ex.InsertException;
import com.cy.store.service.ex.ServiceException;
import com.cy.store.service.ex.UsernameDuplicatedException;
import com.cy.store.util.JsonResult;
import org.springframework.web.bind.annotation.ExceptionHandler;

import java.util.Objects;

/**
 * 控制层的基类
 */
public class BaseController {
    /**
     * 操作成功的状态码
     */
    public static final int OK = 200;

    //请求处理的方法，这个方法的返回值就是需要传递给前端的数据
    //自动将异常对象传递给此方法的参数列表上
    //当前项目中产生了异常，被统一拦截到此方法中，这个方法此时就充当的是请求处理方法，方法的返回值自接给到前端
    @ExceptionHandler(ServiceException.class)     //用于统一处理抛出的异常
    public JsonResult<Void> handleException(Throwable e){     //自定义了一个handException方法
        JsonResult<Void> result = new JsonResult<>(e);
        if (e instanceof UsernameDuplicatedException){  //判断e的数据类型是否属于
            result.setState(4000);
            result.setMessage("用户名已经被占用");
        }else if(e instanceof InsertException){
            result.setState(5000);
            result.setMessage("注册时产生未知的异常");
        }
        return result;
    }
}

重新构建了reg()方法

 @RequestMapping("reg")
    public JsonResult<Void> reg(User user){
        userService.reg(user);
        return new JsonResult<>(OK);//则里尖括号爆红显示java无法推断com.store.util.JsonResult<>的类型参数，
        // 解决办法：在JsonResult中重写public JsonResult（Integer state)方法
    }

这里补充一下访问权限修饰符

public——对所有类可见，任何人都可以使用；

private——仅对本类可见，除类型创建者和类型的内部方法外，其他人不得使用；

protected——对本包和所有子类可见（与private相当，差别是继承的类可以访问protected成员，而不能访问private成员）（继承的类即子类）。

默认访问权限（default）——对本包可见，可以访问同一个包中的其他类的成员，而不能访问其他包的成员。

注册-前端页面

1.在register页面中编写发送请求的方法，点击事件来完成。选中对应的按钮（$("选择器")），再去添加点击的事件。$.ajax()函数发送异步请求。

2.JQuery封装了一个函数，称之为$.ajax()函数，美元符相当于通过对象调用ajax()函数，可以异步加载相关的请求。依靠的是JavaScript提供的一个对象XHR（XmlHttpResponse），封装了这个对象。

3.Ajax（）使用方式，需要传递一个方法体作为方法的参数来使用，一对大括号称之为方法体。ajax接收多个参数，参数与参数之间要求使用”，“进行分割，每一组参数之间使用”：“进行分割，参数的组成部分一个是参数的名称（不能随意定义），是参数的值，参数的值要求使用用字符串来表识。参数的声明顺序没有要求。语法结构：

$.ajax({
	url:"",
	type:"",
	data:"",
    dataType:"",
    seccess:function(){
        
    },
    error:function(){
        
    }
});

ajax()函数参数的含义：

参数	功能描述
url	标识请求的地址（url地址），不能包含参数列表部分的内容。例如：url：“localhost：8080/user/reg"
type	请求类型（GET和POST请求的类型）。例如：type：”POST“
data	向指定的请求url地址提交的数据。例如：data:“username=tom&pwd=123”
dataType	提交的数据类型。数据的类型一般指定为json类型。dataType:“json”
success	当服务器正常响应客户端时，会自动调用success参数的方法，并且将服务器返回的数据以参数的形式传递给这个方法的参数上。
error	当服务器未正常响应客户端时，会自动调用error参数的方法，并且将服务器放回的数据以参数的形式传递给这个方法的参数上。

js代码可以独立存放在一个js的文件里或者声明在一个script标签中。

js代码无法正常被服务器解析执行，体现在点击页面中的按钮没有任何的响应。解决方案：

1. 在项目的maven下clean清理项目然后-install重新部署
2. 在项目的file选项下-cash清理缓存
3. 重新的去构建项目：build选项下-rebuild选项】
4. 重启idea
5. 重启电脑

（2）用户登录

当用户输入用户名和密码将数据提交给后台数据库进行查询，如果存在对应的用户名和密码则表示登录成功，登录成功之后跳转到系统的主页就是index.html页面，跳转在前端使用jquery来完成。

1.登录-持久层

规划需要执行的SQL语句

依据用户提交的用户名和密码做select查询。密码的比较在业务成执行。

select * from t_user where username=？

说明：如果分析过程中发现某一个功能模块已经被开发完成，就可以省略当前的开发步骤，这个分析过程不能够省略。

接口设计和方法

不用重复开发，单元测试也是无需单独执行。

2.登录-业务层

规划异常

1.用户名对应的密码错误，密码匹配失败的异常：PasswordNotMatchException异常，运行时异常，业务异常。

2.用户名没有被找到，抛出异常：UsernameNotFoundException。运行时异常，业务异常

3.异常的编写：

• 业务层异常需要继承ServiceException异常类
• 在具体的异常类中定义构造方法（可以使用快捷键来生成，有5个构造方法）。

设计业务层接口和抽象方法

1.直接在IUserSerivce接口中编写抽象方法，login（String username，String password）。

将当前登录成功的用户数据以当前用户对象的形式进行返回。状态管理：可以将数据保存在Cookie或者session中，可以避免重复度很高的数据多次频繁操作数据进行获取（用户名、用户id-存放在session中，用户头像-cookie中）。

2.需要在实现类中实现父接口中抽象方法。

3.在测试类中测试业务层登录的方法是否可以执行通过。

    @Override
    public User login(String username, String password) {
        //根据用户名称来查询用户的数据是否存在，如果不存在则抛异常
        User result = userMapper.findByUsername(username);//这里我们将找到的结果放在result中，包含用户的所有信息
        if (result == null){
            throw new UserNotFoundException("用户未找到！");
        }
        //检测用户的密码是否匹配
        //1.先获取到数据库中的加密之后的密码,在result中get
        String oldPassword = result.getPassword();
        //2.和用户的传递过来的密码进行比较
        //2.1先获取盐值：要获取的是上一次在注册时所自动生成的盐值，怎么获取？很简单，盐值在上面的result中
        String salt = result.getSalt();
        //2.2将用户的密码按照相同的md5算法的规则进行加密
        String newMd5Password = getMD5Password(password, salt);
        //3.将密码进行比较，判断密码输入是否正确
        if (!newMd5Password.equals(oldPassword)){
            throw new PasswordNotMatchException("用户密码错误！");//这里同样要抛出异常
        }

        //还没完，哈哈，严谨的系统有多种情况需要捕获异常，接下来是将已注销的用户进行判断
        //判断is_delete字段的值是否为1，如果为1则表示被标记为删除
        if (result.getIsDelete() == 1){
            throw new UserNotFoundException("用户已经注销或不存在！");
        }

        //如果上面三个判断都返回的false，则表示已经找到用户的数据，那么我们返回对象数据出去


        //返回不需要全部的用户数据，所以我们将上面的result对象中的数据提取出关键所需的Uid，Username，Avatar
        //这样有一个好处：可以提升系统的性能
        User user = new User(); //new一个user对象来存放三个信息
        user.setUid(result.getUid());
        user.setUsername(result.getUsername());
        user.setAvatar(result.getAvatar());
        return user;
    }

3.登录-控制层

处理异常

业务层抛出的异常是什么，需要在统一异常处理类中进行统一的捕获和处理，如果曾经抛出过的异常类型已经在统一异常处理类中曾经处理过，则不需要重新添加。

else if(e instanceof UserNotFoundException){
            result.setState(5001);
            result.setMessage("用户数据不存在的异常");
}else if(e instanceof PasswordNotMatchException){
            result.setState(5002);
            result.setMessage("用户名的密码错误的异常");
        }

设计请求

请求路径：/users/login

请求方式：POST

请求数据：String username ，String password

响应结果：JsonResult

请求结果

在UserController类中编写请求处理请求的方法。

4.登录-前端页面

1.在login.html页面中依据前面所设置的请求来发送ajax请求。

<!--		下面的是数据与页面控制-->
		<script type="text/javascript">
			$("#btn-login").click(function () {
				$.ajax({
					url: "/users/login",
					type: "POST",
					//serialize自动化
					//这里搞半天没跳转成功，原因是serialize少了（），无语
					data: $("#form-login").serialize(),
					dataType: "JSON",
					success: function (json) {
						if (json.state == 200){
							alert("登录成功")
							//登录成功之后要跳转到主页index
							//相对路径来跳转的页面
							//window.location.href和location.href是一样的
							window.location.href = "index.html";
						}else {
							alert("登录成功")
						}
					},
					error: function (xhr) {
						alert("登录时产生未知的异常"+xhr.message)
					}
				});
			});
		</script>

Springboot自动配置

1.condition

2.切换内置web服务器：SpringBoot提供了4个内置服务器可供选择

<!--第一步：排除tomcat依赖，不做赘述，百度查代码方法-->

<!--第二部：引入jetty的依赖-->
<dependency>
	<artifactId>spring-boot-starter-jetty</artifactId>
	<groupId>org.springframwork.boot</ground>
</dependency>

3.Enable*注解

1. 导入Bean
2. 导入配置类
3. 导入ImportSelector实现类。一般用于加载配置文件中的类
4. 导入ImportBeanDefinitionRegistart实现类

Java监听机制

Springboot的监听机制，其实是对java提供的事件监听机制的封装。

Java的事件监听机制定义了以下几个角色：

1. 事件：Event，继承java.util.EventObject类的对象
2. 事件源：Source，任意对象Object
3. 监听器：Listener，实现java.util.EventListener接口的对象

四个监听器：

1. ApplicationContextInitializer
2. ApplicationRunner
3. ConmmandLineRunner
4. SpringApplicationRunListener

SpringBoot启动流程

Spring boot admin

开源的项目监控工具包，提供单个应用的监控，也可以在idea中的Endpoint中查看

在RunApplication中通过在配置中添加@EnableAdminServer来引入Spring Boot Admin Server配置

spring boot admin有两个角色，客户端（Client）和（Server）。

SpringBoot项目部署

两种方式部署到服务器，jar包，war包。

打war包时记得把pom.xml中的打包方式修改为war。

Springboot自动配置

1.condition

2.切换内置web服务器：SpringBoot提供了4个内置服务器可供选择

<!--第一步：排除tomcat依赖，不做赘述，百度查代码方法-->

<!--第二部：引入jetty的依赖-->
<dependency>
	<artifactId>spring-boot-starter-jetty</artifactId>
	<groupId>org.springframwork.boot</ground>
</dependency>

3.Enable*注解

1. 导入Bean
2. 导入配置类
3. 导入ImportSelector实现类。一般用于加载配置文件中的类
4. 导入ImportBeanDefinitionRegistart实现类

Java监听机制

Springboot的监听机制，其实是对java提供的事件监听机制的封装。

Java的事件监听机制定义了以下几个角色：

1. 事件：Event，继承java.util.EventObject类的对象
2. 事件源：Source，任意对象Object
3. 监听器：Listener，实现java.util.EventListener接口的对象

四个监听器：

1. ApplicationContextInitializer
2. ApplicationRunner
3. ConmmandLineRunner
4. SpringApplicationRunListener

SpringBoot启动流程

Spring boot admin

开源的项目监控工具包，提供单个应用的监控，也可以在idea中的Endpoint中查看

在RunApplication中通过在配置中添加@EnableAdminServer来引入Spring Boot Admin Server配置

spring boot admin有两个角色，客户端（Client）和（Server）。

SpringBoot项目部署

两种方式部署到服务器，jar包，war包。

打war包时记得把pom.xml中的打包方式修改为war。