SpringBoot步骤

SpringBoot

1、引入父项目

若要变成web应用 则引进spring-boot-starter-web依赖

引入其他依赖①spring-boot-starter-web

​                        ②spring-boot-starter-data-redis

​                        ③pring-boot-starter-test

2、写一个启动类  Application

①main方法里写 ：

```
 //运行当前类的加载器
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }
```

②加注解：@SpringBootApplication 

3、写一个测试类TestController 

用@RequestMapping("/test")

```
@RestController
 @GetMapping("/t1")
```

4、在资源包里写 application.yml

配置server

在配置redis:其中配置连接池；

```
 最大等待时间：1000毫秒
 最大活动连接  最大空闲连接(其中还有一个 但是没写出来)
 #最大空闲连接
 #最小空闲连接
```

①要配置redis 需要加依赖spring-boot-starter-data-redis

② 要写一个Test 加依赖spring-boot-starter-test

# SpringBoot

一、介绍：（1）template:动态页面（但是我们一般不会用，一般页面在Vue里面书写）

（2）配置文件它有两种格式，一种叫一样的格式，一种叫 propictionproperty 就是老一点的写法，我们用 property 写法， property 的格式是这种格式

--->1）properties

①--> 单层                       a是键  b是值  a=b

②-->双层                          a.b=c    A 的 B 属性等于 C 

----->2)   yml

①--> 单层                           a:  b

②-->双层                            a:

​                                                 b:  c             a的b等于c

步骤：

1、添加依赖 

①继承spring-boot-starter-parent

②依赖：ioc、aop、mvc的jar包倒进来：spring-boot-starter-web

springboot里面自带 tomcat

2、配置application.yml

```
server:
  port: 8081  #设置服务器端口号  不写默认为8080；
  servlet:
    context-path: /boot01  # 设置项目的这个 tomcat名称
spring:
  application:
    name: boot01 #给项目起了一个名字
```

2、创建软件包  书写Application类 

①@SpringBootApplication :是启动项 所以要加这个注解

②main方法里写 ：

```
public static void main(String[] args) {
    SpringApplication.run(Boot01Application.class,args);
}
```

常见端口号：8080 是tomcat默认端口 

​                        3306 是 MySQL 的端口

​                        80是 IE 的端口号，浏览器的端口号

​                       Redis默认端口号为127.0.0.1,端口号默认为:6379

**创建的所有包都要和Application类 应该跟他在同一个目录级别。

**以emp为案例讲解**

**<一>**全部

1、bean包

(1) Emp:

```
@TableName("emp")//对应emp表
```

```
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("emp")//对应emp表
public class Emp implements Serializable {
    @TableId(type = IdType.AUTO)//自动增长 TableId:主键列设置
    private Integer empno;
    @TableField("ename") //我的这个 ename 对应的是数据库表中的 ename
                            // TableField:非主键列设置
    private String ename;
    private String job;
    private Integer mgr;
    @TableField("hireDate")
    private String hireDate1;
    private Double sal;
    private Double comm;
    private Integer deptNo;
    @TableLogic(value ="1",delval = "0")//删除把1变成0
    private Integer empState;

}
```

序列化作用：通过IO流的方法将他保存在一 什么叫[序列化

[Serializable](https://so.csdn.net/so/search?q=序列化&spm=1001.2101.3001.7020)

  通俗点讲：它是处理对象流的一种机制，即可以很方便的保存内存中java对象的状态，同时也为了方便传输。

(2) 统一返回结果（ResultCode）：

```
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResultCode<T> {

    private String code;
    private String message;
    private T data;
}
```

2、mapper: EmpMapper:

```
@Mapper
public interface EmpMapper {
    @Select("Select * from emp where empstate=1")
    public List<Emp> findAllEmp();
}
```

3、(1)service：EmpService:

```
public interface EmpService {
   ResultCode<List<Emp>> findAllEmp();
}
```

(2) imp: EmpServiceImp:

```
@Service
public class EmpServiceImp implements EmpService {
    @Resource
    private EmpMapper empMapper;
    @Override
    public ResultCode<List<Emp>> findAllEmp(){
        try {
            return new ResultCode<List<Emp>>("200",null,empMapper.findAllEmp());
        } catch (Exception e) {
            e.printStackTrace();
            return new ResultCode<>("500",e.getMessage(),null);
        }
    }
}
```

2、controller包

（1）EmpController

①@RestController:它是 controller + responsebody 它是 new 对象，并且告诉它的方法的返回值，我返回的全部都是数据，而不是页面跳转

②@RequestMapping：这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上。并且一个处理请求地址映射的注解,可用在类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径

```
@RestController
@RequestMapping("/emp")
public class EmpController {
    @Resource
    private EmpService empService;

    @RequestMapping("/a")
    public String a() {
        return "This is EmpController";
    }
@RequestMapping("/b")
    public String[] b() {
        String[] array = {"aa", "bb","cc","dd"};
        return array;
    }
    @RequestMapping("/c")
         public Emp c(){
        Emp emp=new Emp();
        emp.setEmpNo(11);
        emp.setEname("admin");
        return emp;
         }
@GetMapping("/find")
    public ResultCode<List<Emp>> find(){
        return empService.findAllEmp();
    }
}
```

3、SpringBoot集成ORM框架

（1）集成MyBatis框架

1）导jar包

①引入mybatis依赖

```
<!--  引入mybatis的依赖-->
mybatis-spring-boot-starter
```

②数据库连接池

引入依赖druid

```
<!--  引入druid的依赖-->
druid-spring-boot-starter
```

②引入依赖mysql

mysql-connector-java

（2）数据源搭建（在yml文件中）

数据库你要连谁？你的数据库的账号是什么？你数据库的密码是什么

基础四件事

```
url=jdbc:mysql://localhost:3306/emp
driverClassName=com.mysql.cj.jdbc.Driver
password=123456
```

```
datasource:
  type: com.alibaba.druid.pool.DruidDataSource  #使用德鲁伊数据库连接池
  url:
  driver-class-name: com.mysql.cj.jdbc.Driver
  username: root
  password: 123456
  druid:
   #最大活动连接  最大空闲连接(其中还有一个 但是没写出来)  默认是0；
    max-active: 10
     #最大空闲连接
      max-idle: 5
       #最小空闲连接
    min-idle: 6
    #最大等待时间：毫秒
    max-wait: 3000
    map-underscore-to-camel-case: true  #不用在数据库里进行转换
```

4、**mapper：**书写所需要的方法

**service**:  书写一个接口调用mapper里的方法  

​                 用实现类去实现接口里的方法

**controller:**请求响应   接受页面信息  向页面传参。

## **<二>**增删改查

前面都一样

一、**mapper**: EmpMapper: 直接继承BaseMapper

因为BaseMapper里面已经写好基础的单表增删改查的方法

二、**Service:** EmpService :直接继承 IService

因为IService里面已经写好了基础的单表增删改查的方法

三、**imp**:  EmpServiceimp 实现EmpService 继承ServiceImp<m,t>

其中两个泛型：先mapper后是需要的（这里是Emp).

四、**controller**:EmpController

```
@RestController
@RequestMapping("/emp")
public class EmpController {
    @Resource
   private EmpService empService;
    @GetMapping(value = "/find",produces = "{application/json;charset=utf-8")
    public ResultCode<List<Emp>> find(){
        List<Emp> list=empService.list();
        return new ResultCode<List<Emp>>("200",null,list);
    }
    @PostMapping("/save")
    public void save(Emp emp){
      empService.saveOrUpdate(emp);
    }
    @PutMapping("update")
    public void update(Emp emp){
        empService.saveOrUpdate(emp);
    }
    @DeleteMapping("/remove")
    public void remove(int id){
        empService.removeById(id);
    }
}
```

## <三> 按条件检索

前面都一样

一、**mapper**: EmpMapper: 直接继承BaseMapper

因为BaseMapper里面已经写好基础的单表增删改查的方法

```
@Mapper
public interface EmpMapper extends BaseMapper<Emp> {
}
```

二、**Service:** EmpService :直接继承 IService

因为IService里面已经写好了基础的单表增删改查的方法

```
public interface EmpService extends IService<Emp> {
    ResultCode<Emp> find(int id);
}
```

三、**imp**:  EmpServiceimp 实现EmpService 继承ServiceImp<m,t>

```
@Service
public class EmpServiceImp extends ServiceImpl<EmpMapper, Emp> implements EmpService {
    @Override
    @Cacheable(cacheNames = "emp", key = "#id")
    public ResultCode<Emp> find(int id) {
        //通过id进行检索
        Emp emp = baseMapper.selectById(id);
        return ResultTemplate.success(emp);
    }
```

四、**controller**:EmpController

```
@RestController
@RequestMapping("/emp")
public class EmpController {
    @Resource
    private EmpService empService;

    //按姓名进行查询
    @GetMapping("/find1")
    public ResultCode<List<Emp>> find1(String ename){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件(模糊查询）
        wrapper.like("ename",ename);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find2")
    public ResultCode<List<Emp>> find2(String job, double sal){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
        //eq相当于=
        wrapper.eq("job",job);
        wrapper.eq("sal",sal);
        //wrapper.eq("job",job).gt("sal",sal);  和上面一样
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    //按工资的范围搜索
    @GetMapping("/find3")
    public ResultCode<List<Emp>> find3(double sal1, double sal2){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
        wrapper.between("sal",sal1,sal2);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find4")
    public ResultCode<List<Emp>> find4(double sal, int mgr){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
        wrapper.lt("sal",sal).or().eq("mgr",mgr);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    //按部门号的范围搜索
    @GetMapping("/find5")
    public ResultCode<List<Emp>> find5(int dept1,int dept2){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
       wrapper.in("deptno",dept1,dept2);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find6")
    public ResultCode<List<Emp>> find6(String ename){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
       wrapper.inSql("sal","select sal from emp where ename="+ename);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find7")
    public ResultCode<List<Emp>> find7(String sql){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
        wrapper.last(sql);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find8")
    public ResultCode<List<Emp>> find8(String name){
        //条件查询器
        QueryWrapper<Emp> wrapper=new QueryWrapper<>();
        //开始设置条件
       wrapper.select(name);
        List<Emp> list=empService.list(wrapper);
        return ResultTemplate.success(list);
    }
    @GetMapping("/find9")
    public ResultCode<List<Emp>> find9(@RequestParam(name = "page", defaultValue = "1") int page) {
        //每页显示五条
        PageHelper.startPage(page, 5);
        List<Emp> list = empService.list();
        return ResultTemplate.success(list);
    }
    @GetMapping("find10")
    public ResultCode<List<Emp>> find10(int id) {
        return ResultTemplate.success(empService.find(id));
    }
}
```

五、在bean包中书写ResultTemplate:  以后我是不是直接写个 result template.success   不用每次写他  为了不用每次都newResultCode

```
public class ResultTemplate {
    public static ResultCode success(Object data){
        ResultCode resultCode=new ResultCode("200",null,data);
        return  resultCode;
    }
```

简化操作

```
public class ResultTemplate {
    public static ResultCode succrss(Object data){
        ResultCode resultCode=new ResultCode("200",null,data);
        return  resultCode;
    }
```

```
@RestController
@RequestMapping("/emp")
   @Resource
    private EmpService empService;
```

六、（1）引  redis jar包

```
spring-boot-starter-data-redis
```

```
spring-boot-starter-data-redis-reactive
```

 redis一般写到Servicce上

（2） 配置redis(在application.yml中进行配置)

```
redis:
  database: 0
  host: 192.168.38.1 #打开cmd 输入ipconfig进行查询
  password:
  port: 6379
```

(3) 在Application启动类里面添加注解@EnableCaching

变为：

```
@SpringBootApplication
@EnableCaching
public class Boot03Application {
    public static void main(String[] args) {
        SpringApplication.run(Boot03Application.class,args);
    }
}
```

（4）在EmpServiceImp中书写

```
    /*
   1.cacheNames和key必须和查询保持一致
   2.返回结果必须和查询保持一致
   3.1 首先删除数据库中的数据
   3.2 其次删除Redis中指定的Key
   3.3 重新查询数据库中对应的数据
   3.4 存放到Redis中
    */
 @CachePut(cacheNames = "emp", key = "#id")
    public ResultCode<Emp> deleteEmp(int id){
     baseMapper.deleteById(id);
     return ResultTemplate.success(baseMapper.selectById(id));;
 }
}
```

```
@Service
public class EmpServiceImp extends ServiceImpl<EmpMapper, Emp> implements EmpService {
    @Override
    @Cacheable(cacheNames = "emp", key = "#id")
    public ResultCode<Emp> find(int id) {
        //通过id进行检索
        Emp emp = baseMapper.selectById(id);
        return ResultTemplate.success(emp);
    }

    /*
   1.cacheNames和key必须和查询保持一致
   2.返回结果必须和查询保持一致
   3.1 首先删除数据库中的数据
   3.2 其次删除Redis中指定的Key
   3.3 重新查询数据库中对应的数据
   3.4 存放到Redis中
    */
 @CachePut(cacheNames = "emp", key = "#id")
    public ResultCode<Emp> deleteEmp(int id){
     baseMapper.deleteById(id);
     return ResultTemplate.success(baseMapper.selectById(id));
 }
}
```

二 序列化有什么作用

  1.方便传输，速度快，还很安全，被调用方序列化，调用方反序列化即可拿到传输前最原始的java对象，常用于不同进程之间的对象传输

  2.方便存储，不管是存储成文件还是数据库，都行，存储为文件，下回要用可以直接反序列拿到对象

为什么我们要面向接口显示：

易于扩展，松耦合

因为接口不实现对不对？只要我符合这个接口的规范，我是不是都可以产品管这样的话我要的是啥？要的是一种规范的效果，而不是什么而不是实现的效果。

接口可以继承接口  但是不能继承类

API测试里  post--->body