spring boot 基础问题

https://www.oschina.net/question/2491333_2275473

Spring Boot是一套遵循的约定大于配置的体系，简化了很多组件的使用比如datasouce、JPA、SpringMVC等等，约定好自动化的配置，就可以使用功能。使用的技术还是Spring体系的，Spring mvc在其中也有使用。同时SpringBoot有各种starter，包含了当前功能必须的各种Maven依赖，简化了依赖冲突的管理问题。本质来说就是个常用开发框架整合包，类似与项目开始开发拿到的初始可运行框架。

SpringMVC是一个Spring解决WEB开发问题提供的一个MVC框架，框架的使用配置需要开发人员自行配置，依赖也需要自行引入，只是搭建项目可运行框架的一部分。

开发中，突出的差别体现感觉是在：

注解和xml配置的使用上，SpringBoot基本可以用注解实现所有功能。

启动方式变更，以前的大部分都是打包后放在诸如tomcat之类的容器运行，现在SpringBoot内置了容器，通过Applicaiton的main函数可以直接运行。

https://blog.csdn.net/qq_37385181/article/details/78693838

Spring MVC是什么？

(1)Spring MVC是Spring提供的一个强大而灵活的模块式web框架。通过Dispatcher Servlet, ModelAndView 和 View Resolver，开发web应用变得很容易。
(2)SpringMVC是一种基于Java的以请求为驱动类型的轻量级Web框架，其目的是将Web层进行解耦，即使用“请求-响应”模型，从工程结构上实现良好的分层，区分职责，简化Web开发。借助于注解，Spring MVC提供了几乎是POJO的开发模式，使得控制器的开发和测试更加简单。这些控制器一般不直接处理请求，而是将其委托给Spring上下文中的其他bean，通过Spring的依赖注入功能，这些bean被注入到控制器中。
(3)Spring框架最核心的就是所谓的依赖注射和控制反转。完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。

SpringMVC的优点：

(1)使用简单，学习成本低。
(2)很容易就可以写出性能优秀的程序.
(3)灵活性强，Spring MVC的框架易扩展

SpringMVC的缺点：

(1)Spring与MVC 的Servlet API 耦合，难以脱离容器独立运行
(2)太过于细分，开发效率低
(3)过度追求完美，有过度设计的危险

解决的问题领域是：
网站应用程序或者服务开发——URL路由、Session、模板引擎、静态Web资源等等。

Spring Boot是什么？

Spring Boot 引入自动配置的概念，让项目设置变得很容易。Spring Boot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。同时它集成了大量常用的第三方库配置(例如Jackson, JDBC, Mongo, Redis, Mail等等)，Spring Boot应用中这些第三方库几乎可以零配置的开箱即用(out-of-the-box)，大部分的Spring Boot应用都只需要非常少量的配置代码，开发者能够更加专注于业务逻辑。Spring Boot只是承载者，辅助开发者简化项目搭建过程的。如果承载的是WEB项目，使用Spring MVC作为MVC框架，那么工作流程和SpringMVC的是完全一样的，因为这部分工作是Spring MVC做的而不是Spring Boot。

Spring Boot的核心功能：

（1）独立运行的Spring项目
Spring Boot可以以jar包的形式进行独立的运行，使用：java -jar xx.jar就可以成功的运行项目，或者在应用项目的主程序中运行main函数即可；

（2）内嵌的Servlet容器
内嵌容器，使得我们可以执行运行项目的主程序main函数，并让项目的快速运行；

（3）提供starter简化Maven配置
Spring Boot提供了一系列的starter pom用来简化我们的Maven依赖

（4）自动配置Spring
Spring Boot会根据我们项目中类路径的jar包/类，为jar包的类进行自动配置Bean，这样一来就大大的简化了我们的配置。当然，这只是Spring考虑到的大多数的使用场景，在一些特殊情况，我们还需要自定义自动配置；

（5）应用监控
Spring Boot提供了基于http、ssh、telnet对运行时的项目进行监控；

springboot 要解决的问题：

1.如何精简配置；如何让编码、部署、监控变简单；
2.如何方便的让spring生态圈和其他工具链整合

优点：

对新手来说，无需任何门槛，只要懂Maven[的新手]会看文档就能亦步亦趋的开始一个新项目；对高手来说，改配置也是分分钟的事。另外fat
jar的打包方式让部署方式变得优雅。

缺点：

就是简单的背后蕴藏了巨大的学习曲线。入门容易，但是如果没有完整学习spring的体系，碰到问题就一脸懵逼。如果没有一定的经验，根本就不知道springboot自动做了什么。

SpingMVC与SpringBoot的联系与区别：

联系：

Spring 最初利用“工厂模式”（ DI ）和“代理模式”（ AOP ）解耦应用组件。按照这种模式搞了一个 MVC 框架（一些用Spring 解耦的组件），用开发 web 应用（ SpringMVC）。后来发现每次开发都要搞很多依赖，写很多样板代码，使代码臃肿而麻烦，于是聪明的前人整理了一些懒人整合包（ starter ），这套就是Spring Boot 。

区别：

Spring MVC 是基于 Servlet 的一个 MVC框架主要解决 WEB 开发的问题但关于Spring 的配置比较；
而Spring boot 的原则是：约定优于配置，可以极大地简化了 spring 的配置流程。

约定大于配置理解

https://www.cnblogs.com/panxuejun/p/6710888.html
spring boot和maven的约定大于配置体现在哪些方面?

两者都遵从了约定大于配置的路线

约定优于配置体现点：

1.maven的目录文件结构

1）默认有resources文件夹,存放资源配置文件。src-main-resources,src-main-java默认的编译生成的类都在targetwen

2）默认有target文件夹，将生成class文件盒编程生成的jar存放在target文件夹下

2.spring boot默认的配置文件必须是，也只能是application.命名的yml文件或者properties文件，且唯一

1）spring boot默认只会去src-main-resources文件夹下去找application配置文件

Spring 与 Sping Boot

https://blog.csdn.net/fxq8866/article/details/76794961?foxhandler=RssReadRenderProcessHandler

Spring在JavaEE开发中是实际意义上的标准，但是开发中会遇到下述问题

大量配置文件的定义
与第三方软件整个的技术问题

而Spring每个新版本的推出都以减少配置作为自己的主要目标

（1）注解声明Bean
（2）Java配置代替xml配置

SpringBoot具有如下特点

（1）习惯优于配置，大多数配置默认，只需很好配置
（2）项目快速搭建，无配置整合第三方框架
（3）自动配置和Java配置
（4）内嵌Servlet（Tomcat）容器，应用可jar包运行
（5）运行中应用状态的监控

Bean是什么

https://blog.csdn.net/sinat_15274667/article/details/49474875

Spring里面的bean就类似是定义的一个组件，而这个组件的作用就是实现某个功能的，在spring里给定义的bean就是说，我给你了一个更为简便的方法来调用这个组件去实现你要完成的功能

 <!-- 利用set注入Dog -->
    <bean id="d1" class="com.yang.Dog">
        <property name="name" value="lala"></property>
        <property name="age" value="9"></property>
        <property name="style" value="Hashiqi"></property>
    </bean>
    <!--利用set注入person-->
    <bean id="d2" class="com.yang.person">
        <constructor-arg index="0" value="andreny"></constructor-arg>
        <constructor-arg index="1" value="15454"></constructor-arg>
        <constructor-arg index="2" value="teacher"></constructor-arg>
    </bean>

比如，上面的代码中，这个id就是bean的别名，这样可以很方便后面的关联，使用时你需要那个关联哪个的别名就行了，就像我下面需要上面定义的注入的dog和person，那么我只需要在关联它就行了，在action中set注入便可。

<bean id="m1" class="com.yang.myshow">
        <property name="dog" ref="d1"></property>
        <property name="p" ref="d2"></property>
    </bean>
</beans>

还有bean的作用域分别有：
singleton，prototype，request，session，global.session物种，其中前2个用在spring中，后面三个用在web中

https://zhidao.baidu.com/question/512130164.html

我个人的理解，觉得bean就相当于定义一个组件，这个组件是用于具体实现某个功能的。这里的所定义的bean就相当于给了你一个简洁方便的方法来调用这个组件实现你要完成的功能。

对于我们的spring最主要的应该就是由这些bean组成的bean工厂，每个bean实现一个功能
例如：你写的第一个bean

<bean id="userAction" class="com.neusoft.gmsbs.gms.user.action.UserAction"
scope="prototype">
<property name="userBO" ref="userBO" />
</bean>

id相当于定义了你的这个bean的别名，如果你需要他的话只要关联这个别名就可以了，也就相当于下面的<property name="userBO" ref="userBO" />一样，在你的userAction中需要实现userBO这个功能，我关联它，那么在action中set注入就可以使用了！

至于其他的属性看下面：

Id : 标识该bean的名称，通过factory.getBean(“id”)来获得实例。
Class : 该bean的类路径。
Singleton : 默认为true，即单实例模式，每次getBean(“id”)时获取的都是同一个实例，如果设置为false，即原型模式，则每次获取的是新创建的实例。
Init-method :在bean实例化后要调用的方法(bean里定义好的方法)。
Destroy-method : bean从容器里删除之前要调用的方法。
Autowire : 其属性要通过何种方法进行属性的自动装配。

对于上述的各个属性，id和class是必要的，其他的则可以省略。例如如果设置了autowire的值，则表明需要自动装配，否则是手动装配。

https://www.cnblogs.com/alltime/p/6729295.html

依赖注入的简单理解

所谓依赖，举个例子说明，一个类Person，另一个类Car，如果Person的某个方法比如说drive，需要引用Car，则称Person类依赖于 Car类，延伸到对象，这种依赖关系依然成立，比如说Person类的对象boy依赖于Car类的对象toyota。再讲讲这个drive方法的实现，假定代码如下：

Public Person{
...
public void drive(){
  Car toyota=new Car("TOYOTA");
  toyota.挂档;
  toyota.踩油门;
  toyota.打方向;
}
}

这其中的依赖关系，就导致了对象boy需要负责对象toyota的创建，甚至是整个生命周期的管理，而这样显然会带来耦合度高，不易维护等缺点，比如说要让这个男孩驾驶一辆Audi，则还需要修改类Person的代码。
因此在java的设计理论中就提出了一条非常著名的原则，依赖倒转原则（Dependence Inversion），其核心思想就是要将这种具体类之间的依赖，尽量转换成抽象依赖，也就是说类Person应该依赖于抽象类ICar，而不是具体的类 Car，这里java就大力推荐了抽象和接口的使用，至于抽象和接口之间的区别，任何一本JAVA书籍都有介绍，这里就不再说了。
这个依赖倒转原则在设计模式也体现得非常多，比如说工厂模式和构建模式，个人认为控制反转IoC，其实也可以认为是实现这个原则的一种设计模式。控制反转，其中的控制这个词一直不太理解是什么意思，不过控制反转的另外一种说法也就是依赖注入（dependence injection），个人觉得更易于理解。还是以上文的boy与toyota为例，其核心就是要将boy依赖的对象toyota注入到boy中去，而无需boy自己去引用toyota，这个注入的过程，通常是由一个控制程序来完成的，无需对象去关心，举例如下：

Public Person{
private ICar car;
public Person(ICar onecar){
  car=onecar;
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
}

这个时候，进行注入并且调用的过程，就很简单了，如下：

 Toyota toyota=new Toyota();
Person boy=new Person(toyota);
boy.drive();

注：这里我们假定，Toyota类是ICar接口类的一个具体实现。
这个例子就演示一个最简单的注入方式的例子，也就是构造子方式注入，通过将依赖对象注入到对象的构造子中来实现。另外还有一种常用的注入方式，就是属性方式注入，意思就是通过将依赖对象注入到对象的属性中来实现，还是以boy和toyota的例子说明，如下：

Public Person{
private ICar car;
public Person(){
}
public void drive(){
  car.挂档;
  car.踩油门;
  car.打方向;
}
public ICar getCar(){
  return this.car;
}
public void setCar(ICar onecar){
  car=onecar;
}
}

这个时候，进行注入并且调用的过程，就变成如下所示：

Toyota toyota=new Toyota();
Person boy=new Person();
boy.setCar(toyota);
boy.drive();

至此依赖注入的概念应该比较清楚了，再来看看在Spring中如何实现IoC的，看看Spring如何作为一个成熟的IoC容器，Spring中其实主要通过两个概念来实现IoC，首先通过XML配置文件，将对象和依赖对象都配置到某个XML文件中，当然该XML文件需要符合Spring指定的规范，然后通过架构中的BeanFactroy类，来自动实现上文所述注入过程，还是以boy与toyota为例，如下：
首先，Person类还是一样的，
然后xml配置文件增加点东西-（假定为bean.xml）：

<?xml version="1.0" encoding="GBK"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   <bean id="oneCar" class="Toyota"> <!-- Toyota类是ICar的一个实现-->
   </bean>
   <bean id="onePerson" class="Person"> <!--本例以属性方式注入为例 -->
       <property name="car"> 
           <ref bean="oneCar"></ref>
       </property>
   </bean>
</beans>

最后，调用的过程，就变成如下：

BeanFactory factory=new XmlBeanFactory("bean.xml");
Person boy=(Person )factory.getBean("onePerson");
boy.drive();

依赖注入:并不是那么复杂.

A类和B类,如果A要用到B
在A类中加一个setB()就OK了,再通过spring的IOC容器实例化好的对象用属性注入就OK了