springboot基础

前置知识

1.Spring框架中两个核心概念

Bean和AOP(面向切面编程)

1.bean

1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成

IoC

IoC:(Inversion of Control)控制反转，通过依赖注入（DI）方式实现对象之间的松耦合关系。

程序运行时，依赖对象由【辅助程序】动态生成并注入到被依赖对象中，动态绑定两者的使用关系。

这里的Spring IoC就是”辅助程序”，负责对象的生成和依赖的注入。

可以看做：IoC就是一个对象定义其依赖关系而不创建它们的过程。

从两点去细分它

1.私有属性保存依赖

私有属性保存依赖对象，且只能通过构造函数参数传入

参数可以是工厂方法、保存类对象的属性、或者是工厂方法返回值。

假设有一个Food类

public class Food{
	private Integer price;//价格
    private String weidao;//味道
    
    public Food(Integer price,String weidao){
        this.price=price;
        this.weidao=weidao;
    }
}

如果有一个Person类依赖Food类；

符合IoC的做法：

public class Person {
    private Food food;

    public Person(Food food) {
        this.food = food;
    }
}

不符合IoC的做法：

1.直接在Person类中去实例化

public class Person {
    private Food food = new Food(200, "好吃");
}

2.通过【非构造函数】传入依赖

public class Person {
    private Food food;
    
    public void otherfunction(Food food) {
        this.food = food;
    }

2.Spring控制类构建过程

不用new，让Spring去控制new过程

Spring 启动时会把所需的类实例化成对象，如果需要依赖，则先实例化依赖，然后实例化当前类。

因为依赖必须通过构建函数传入，所以实例化时，当前类就会接收并保存所有依赖的对象。

这一步即为 依赖注入

总结

在 Spring 中，类的实例化、依赖的实例化、依赖的传入都交由 Spring Bean 容器控制，

而不是用new方式实例化对象、通过非构造函数方法传入依赖等常规方式。

实质的控制权已经交由程序管理，而不是程序员管理，所以叫做控制反转。

bean的概念

概念1：Bean容器，或称spring ioc容器，主要用来管理对象和依赖，以及依赖的注入。
概念2：bean是一个Java对象，根据bean规范编写出来的类，并由bean容器生成的对象就是一个bean。
概念3：bean规范。

bean的规范

1.所有属性为private
2.提供默认构造方法
3.提供getter和setter
4.实现serializable接口

来源

CSDN carpe_diem0

一、概述

集成了大量常用的第三方库配置，Spring Boot应用中这些第三方库几乎可以是零配置的开箱即用（out-of-the-box），大部分的 Spring Boot 应用都只需要非常少量的配置代码（基于 Java 的配置），开发者能够更加专注于业务逻辑。

1.优点

1.简化编码

创建一个web项目时，Spring Boot 则会帮助开发者快速启动一个 web 容器，只需要在pom文件下添加一个 starter-web 依赖

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

该依赖已经包含了其他依赖，一个依赖足以简化编码

2.简化配置

Spring 虽然使Java EE轻量级框架，但由于其繁琐的配置，一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱；E而Spring Boot更多的是采用 Java Config 的方式，对 Spring 进行配置

@Configuration
public class JavaConfig {
    @Bean
    public TestService getTestService() {
        return new TestService();
    }
}

需要使用该bean时，则
@Resource
private TestService testService;

@Configuration表示该类是个配置类，@Bean表示该方法返回一个 Bean。这样就把TestService作为 Bean 让 Spring 去管理

部署配置方面，原来 Spring 有多个 xml 和 properties配置，在 Spring Boot 中只需要个 application.yml即可

3.简化部署

内嵌了tomcat，只需要将项目打包成jar包，启动项目即可

4.简化监控

引入 spring-boot-start-actuator 依赖，直接使用 REST 方式来获取进程的运行期性能参数，从而达到监控的目的，比较方便

2.spring boot工程

1.maven

maven，通俗来讲，指项目管理工具

主要作用为：

1)进行依赖管理(我们做项目用到的jar包在maven中称为依赖)

2)构建项目(项目编译、打包、测试、部署)

3)分模块开发,提高开发效率

2.项目三模块

• src/main/java路径：主要编写业务程序
• src/main/resources路径：存放静态文件和配置文件
• src/test/java路径：主要编写测试程序

默认情况下，项目只有一个启动类，它有个main方法。启动时运行该main方法即可。

3.spring boot返回Json数据及数据封装

在项目开发中，接口与接口之间，前后端之间数据的传输都使用 Json 格式

在 Spring Boot 中，接口返回 Json 格式的数据很简单，在 Controller 中使用@RestController注解即可返回 Json 格式的数据

该注解包含为：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    String value() default "";
}

@Controller注解

@Controller标识的类，该类代表控制器类(控制层/表现层)。
这里控制层里面的每个方法，都可以去调用@Service标识的类（业务逻辑层）（当然了，控制器也是Spring来管理的）
@Service标识的类中的方法可以继续调用@Resposity标识的接口实现类（Dao层/持久层）。

可以了解到一个MVC架构模式

我首次接触到MVC还是在ASP.NET的web开发中

M(模型)、V（视图）、C（控制器）

HTML页面数据–>控制器–>数据逻辑处理并持久化

@Controller只是定义了一个控制器类，而使用 @RequestMapping 注解的方法才是处理请求的处理器。

@Controller
public class PageController {
	@RequestMapping(value="/login")
	public String str(String s) {
		return "logining";
	}
}

结果就是返回到logining.html

用@Controller定义一个控制器类，
用@RequestMapping给出外界访问方法的路径，或者说触发路径 ，触发条件。
用@ResponseBody标记Controller类中的方法。把return的结果变成JSON对象返回。（如果没有这个注解，这个方法只能返回要跳转的路径即跳转的html/JSP页面。有这个注解，可以不跳转页面，只返回JSON数据）

Spring Boot 中默认使用的 Json 解析技术框架是 jackson

依赖于

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
    <version>2.0.3.RELEASE</version>
    <scope>compile</scope>
</dependency>

3.1.Spring Boot默认对Json的处理

在实际项目中，常用的数据结构无非有：类对象、List对象、Map对象，它们都可以转化成json格式

3.2.fastjson与jackson

目前的项目都是fastjson，从扩展上来看，fastJson 没有 jackson 灵活，从速度或者上手难度来看，fastJson 可以考虑

使用fastjson需要导入依赖，如：

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.35</version>
</dependency>

3.3.封装统一返回的数据结构

实际项目中，除了封装数据，还要在返回的json中添加其它消息，如状态码code，msg给调用者，使得调用者做出一些逻辑判断。所以实际项目中，需要封装一个统一的json结构。

*3.3.1 定义统一的json结构

由于封装的 json 数据的类型不确定，所以在定义统一的 json 结构时，我们需要用到泛型。

统一的 json 结构中属性包括数据、状态码、提示信息即可，构造方法可以根据实际业务需求做相应的添加即可，一般来说，应该有默认的返回结构，也应该有用户指定的返回结构

如下：

public class JsonResult<T> {
    private T data;
    private String code;
    private String msg;
 
    /**
     * 若没有数据返回，默认状态码为0，提示信息为：操作成功！
     */
    public JsonResult() {
        this.code = "0";
        this.msg = "操作成功！";
    }
 
    /**
     * 若没有数据返回，可以人为指定状态码和提示信息
     * @param code
     * @param msg
     */
    public JsonResult(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }
 
    /**
     * 有数据返回时，状态码为0，默认提示信息为：操作成功！
     * @param data
     */
    public JsonResult(T data) {
        this.data = data;
        this.code = "0";
        this.msg = "操作成功！";
    }
 
    /**
     * 有数据返回，状态码为0，人为指定提示信息
     * @param data
     * @param msg
     */
    public JsonResult(T data, String msg) {
        this.data = data;
        this.code = "0";
        this.msg = msg;
    }
    // 省略get和set方法
}

比如有个UserInfopo类

public class UserInfopo {

        private Integer no;
        private String name;
        private String number;

   		public UserInfopo(Integer no, String name, String number) {
        this.no = no;
        this.name = name;
        this.number = number;
    }
}

在TestController设置如下

@RestController("testController")
public class TestController {

    @RequestMapping("/test1")
    public JsonResult<UserInfopo> test(){
        UserInfopo user=new UserInfopo(1,"Yuleiyun","123445");
        return new JsonResult<>(user);
    }
}

不但将数据通过 json 传给前端或者其他接口，还带上了状态码和提示信息，这在实际项目场景中应用非常广泛