JavaWeb笔记整理+SSM+SpringBoot（基础）

1.C/S 与2. B/S

C/S结构应用程序（Client/Server）：客户端----服务器结构。 凡是需要在客户的机器上安装客户端软件的应用程序都是CS架构的应用程序。

• 优点：响应速度快，安全性强，一般应用于局域网中。
• 缺点：需要经常更新客户端，开发维护成本高。

B/S结构应用程序（Browser/Server）：浏览器----服务器结构。 凡是使用浏览器运行的应用程序都是BS架构的应用程序。

• 优点：跨平台，客户端零维护，即不需要更新客户端。
• 缺点：响应速度受制于网络。

3.HTTP协议:超文本传输协议    html:超文本标记语言

3.1:请求方式：

    1.get：明文方式  url中  最多2kb  速度快

    2.post：密文方式  加密  大小无限制  速度慢

3.2：URL：统一资源定位符

    用于完整地描述Internet上网页和其他资源的地址的一种标识方法。就是我们通常所说的网址。

    http://localhost:8080/javaweb/index.html

    http：超文本传输协议

    localhost:8080：本机的IP地址＋端口号

    javaweb：运行的项目名称

    index.html：项目具体文件

    

javaSE 基础版 控制台打印输出数据

javaEE是java的企业级版本，可以用来开发B/S结构应用程序。

tomcat8.0   -----------jdk1.7以上

tomcat9.0   -----------jdk1.8以上

1、Servlet技术

Servlet是用Java语言编写的运行在服务器端的程序,能 够接收Web客户端的请求,

并能对 Web客户端进行响应,通常是通过HTTP协议进行工作的。

Servlet文件必须在服务器中运行

Servlet的主要作用有:

1、读取客户发送的所有数据

2、查询 HTTP 请求中包含的任何其他请求信息

3、处理数据并生成结果  调用JDBC存入数据库

4、设置合适的 HTTP 响应参数

5、将响应信息回送给客户端

doGet:提交方式：get 在网址后追加数据

doPost:提交方式：post 把数据存入  http协议里

doGet   doPost 都继承自Genericservlet的service()方法。

service()方法：是系统自动调用判断请求方式是get还是post

参数：

    1、request：请求转发  获取前端数据，服务器内部对象，跳转页面，存储数据

    2、response：响应  发送数据  跳转页面

         //跳转百度 外网response(站内+站外）

         //项目内部文件request与response都可

设置字符集：

 //设置请求信息的字符编码（必须在使用request之前进行设置）

request.setCharacterEncoding("utf-8");

//使客户端浏览器并根据不同的MIME调用浏览器内不同的程序嵌入模块来处理相应的数据。

response.setContentType("Text/html;charset=utf-8");

1、一个类继承HttpServlet类，我们就将它称为一个Servlet。

2、继承HttpServlet类后，必须要重写doGet和doPost方法。

3、doGet和doPost方法都有两个参数：HttpServletRequest、HttpServletResponse HttpServletRequest：封装了请求信息。 HttpServletResponse：封装了响应信息。

4、使用HttpServletRequest对象中的getParameter方法获取客户端提交参数。 使用HttpServletResponse创建响应输出流，向客户端响应信息。

5、@WebServlet注解中，使用urlPatterns属性来设置Servlet映射：

    将客户端请求映射到对应的Servlet上。

    @WebServlet(urlPatterns="/hello")

    简写为：@WebServlet("/hello")

生命周期：

    1、加载类 构造累 ----构造方法

    2、init（）------初始化

    3、doget/dopost   service（）

    4、distroy ---- 销毁

实例化：servlet容器创建servlet对象。默认创建servlet实例的时机：当我们发送servlet对应的请求时(在使用时创建)。类似单例模式中的懒加载方式。希望容器一旦启动，就自动创建servlet实例通过load-on-startup=1设置，正数数值越低优先级别越高，优先实例化

初始化：servlet实例一旦创建，就开始初始化一些参数配置，我们可以做一些参数配置，比如编码，可以在web.xml或注解中配置

就绪状态：当发送对应的servlet请求时，会调用service()方法，注意此时不会重新创建servlet实例，也不会调用init()方法  Service（）决定调用doGet还是doPost

销毁状态：调用了destroy()方法后，当前servlet实例将会被标记为回收垃圾，会对servlet实例进行清除处理

————————————————

servlet:3.0,3.1,4.0

从3.0开始可以使用@WebServlet()注解

Servlet对象由Web服务器负责创建，创建的时机可以使用loadOnStartup属性进行配置

1、loadOnStartup属性的值必须是一个整数，表示servlet应该被载入的顺序

2、当值为0或者大于0时，表示容器在应用启动时就加载并初始化这个servlet；

3、当值小于0或者没有指定时，则表示容器在该servlet被选择时才会去加载。

4、正数的值越小，该servlet的优先级越高，应用启动时就越先加载。

5、当值相同时，容器就会自己选择顺序来加载。

6、取值1，2，3，4，5代表的是优先级，而非启动延迟时间。

Http 状态码：

1.404错误：找不到请求的资源  资源映射没有匹配

2.505错误：服务端代码错误  后台Java报错 服务器编码错误

3.200 成功

Servlet返回JSON数据

MVC设计模式：分层架构模式（分层开发）

M:model  模型层

V: view  视图层

C:controller  控制层

   M                        C                        V

模型层  <---------控制层---------->视图层

高内聚低耦合：

低耦合：模块之间使用接口降低耦合度。

高内聚:每个模块相对独立

目的：使得软件工程实现 “可重用、可扩展、可维护、灵活性好” 的目的。

模型层:1.   数据库表封装bean 

           2．数据库连接DBUtil 

           3．业务逻辑层dao(接口与实现类)

           4.   service层调用管理层

控制层 ：Servlet

视图层：HTML SCC JS VUE 。。。

跨域：CORS

CORS是H5新增的一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）。

特点:

1．跨域只存在于浏览器端，不存在于其它环境

2、CORS配置要写在服务器端,是在response 发送响应时进行的配置

    浏览器拦截response所以要通过response 解除拦截（跨域）

getContextPath ()返回根路径

9. request与response

站内:request  服务器内部进行资源跳转站外资源无法访问

    跳转页面：浏览器看不到具体过程，浏览器地址栏不会发生变化

    一次请求，一次响应

站内站外: response  

    跳转页面：浏览器了解具体资源路径信息，浏览器的地址栏会发生变化

    多次请求，多次响应

10：在javaEE中有三大标准组件：Servelt、Filter（过滤器）、Listener（监听器）

    过滤器:

                                      request

    浏览器------>发送请求------>过滤器------>Servlet

                                      response

    Servlet------>返回响应------>过滤器-------->浏览器

11:.Listener 监听器

    案例：监听服务器启动

12：JSP  JavaServerPage  Java服务器文件  本质：Servlet

       vue.js 可以实现 跨域访问 完全的前后端分离 jsp过时了。。。

13：Servlet会话跟踪：

    1、Cookie

        Cookie由服务器生成，然后发送给客户端浏览器，

        浏览器会将Cookie保存到客户端内存中或者保存到客户端某个目录下的文本文件内。

        //实例：自动登录  保存信息下次访问直接的登录

   

 2、session  

定义了session的超时时间，时间单位是分  默认30分钟

cookie   与  session

cookies数据保存在客户端

面向的网站数据

session数据保存在服务器

面向的是用户数据

存储数据的大小不同

1. cookie 3KB

2. session任意大小数据服务器不定时清理

cookie长期有效

session

面试题:什么是URL重写?或禁用cookies后Session如何使用?

session 依赖于JSESSIONID的 cookies如果禁用了cookies session也无效了解决办法:提前通过servlet(session.getId())获取了SESSIONID将其拼接到访问路径的后面

response.encodeRedirectURL(session.getId());   session 也可以使用

//注意：这里设置只允许 http://localhost:8080 进行跨域访问

//response.setHeader("Access-Control-Allow-Origin", "http://localhost:8080");

   response.setHeader( "Access-Control-Allow-Origin", "*");

//当跨域请求需要携带cookie时，请求头中需要设置Access-Control-Allow-Credentials:true。

response.setHeader( "Access-Control-Allow-Credentials", "true");

//跨域提交方式

response.setHeader( "Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE, PUT");

//跨域请求时间Access-Control-Max-Age用来指定本次预检请求的有效期，单位为秒

response.setHeader( "Access-Control-Max-Age", "3628800");

//设置本次跨域的头部信息 防止上传照片时跨域拦截

response.setHeader( "Access-Control-Allow-Headers", "x-requested-with,Authorization");

chain.doFilter( request, response);

//获取参数

request .getParameter( )

//返回数组

request .getParameterValues( )

//重定向

response.sendRedirect(" http://www.baidu.com");   站外

response.sendRedirect(request.getContextPath()+"/Test.html")  站内

getContextPath ()返回根路径

//转发

request.getRequestDispatcher("Test.html").forward(request,response);

//获取写入流

PrintWriter out = response.getWriter()

out.println();

out.flush(); //刷

//关闭响应输出流

out.close();//自动调用flush

//JSON转换 

ObjectMapper om = new ObjectMapper();

//转成JSON

om .writeValueAsString(数组、对象。。。 )

// request.getCookies() 返回cookie数组

Cookie[] cArr = request.getCookies();

cookie .getName()

cookie .getValue()

//创建Cookie                                    

Cookie cookie = new Cookie( name , value)

//设置Cookie过期时间为30秒

cookie.setMaxAge(30);

//向客户端发送Cookie

response.addCookie( cookie);

response.setContentType(MIME)的作用是使客户端浏览器，区分不同种类的数据

假设你的web application 名称为myapp,你在浏览器中输入请求路径：

http://localhost:8080/myapp/main/index.jsp

则执行下面向行代码后打印出如下结果：

1、 System.out.println(request.getContextPath());

打印结果：/myapp

2、System.out.println(request.getServletPath());

打印结果：/myapp/index.jsp

3、 System.out.println(request.getRequestURI());

打印结果：/myapp/main/index.jsp

4、 System.out.println(request.getRealPath("/"));

打印结果： F:\Tomcat 6.0\webapps\myapp\test

对数据库修改需要提交事务

增删改在catch中回滚事务

finally中提交事务

动态sql查询：多条件查询

    if:条件判断

        text：逻辑表达式

    where:

    set:

    

单条件条件查询：

    choose（when,otherwise）

    choose         switch

        when             case

        otherwise      defult    一般用where

主键返回： useGeneratedKeys ="true" keyProperty ="id"

批量删除：将所要删除的数据存入数组中

mybatis会将数组参数封装为一个Map集合。

    *默认key：array = 数组

    *使用@param注解改变集合的默认key的名称

in{

            #{id}

}

    

        

        

        

            

            

                

    

JSP

JSP与Servlet的区别:        JSP:  Java Serve  Page

1.JSP本质上就是Servlet二者都共同继承一个父类（HttpServlet）

2.JSP其实就是前端的servlet文件

    九大内置对象：

        1、request对象

        2、response对象

        3、session对象

        4、application对象:对象可将信息保存在服务器中，直到服务器关闭

        5. out 对象用于在web浏览器内输出信息

        6. pageContext 对象

        7. config 对象配置文件

        8. page对象

        9. exception 对象|

    四大作用域：

         pageContext（page 域对象）、request（request 域对象）、session（session 域对象）、以及 application（application 域对象）

3.JSP还可以去编译Html css js

为什么需要框架技术：

     帮我们更快更好地构建程序

    是一个应用程序的半成品

     提供可重用的公共结构

     按一定规则组织的一组组件

优势：

    不用再考虑公共问题

    专心在业务实现上

     结构统一，易于学习、维护

    新手也可写出好程序

Java世界中的主流框架技术： Spring、SpringMVC、MyBatis、Struts、Hibernate、SpringBoot等

SSM框架之Mybatis

SSM：Spring + SpringMVC + MyBatis

SSH框架：Spring + Struts + Hibernate

Struts：漏洞较多，安全性较差

Hibenate：对接数据库业务，不能灵活配置要运行的sql语句,需要学习Hibernate sql语法格式，全自动化

ORM（对象-关系映射）：完成对象数据到关系型数据映射的机制称为对象-关系映射。

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。 也就是说：iBatis3.0之后都要改名为MyBatis 。

MyBatis 是基于Java的支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。ORM框架，半自动化

作用：在实体类和sql语句之间建立映射关系，代替JDBC

优点：基于SQL语法，简单易学。能了解底层组装过程。

          SQL语句封装在配置文件中，便于统一管理与维护，降低了程序的耦合

          程序调试方便。

MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。

XML：配置文件  sql语句

实际上，MyBatis最核心的功能，就是实现了 输入映射和输出映射

3.Mybatis(非maven工程)环境搭建

  1.mybatis 核心jar包

  2.mysql数据驱动jar

  3.commons-logging-1.2jar包

  4.log4j jar记录程序日志

  5.日志文件log4j.propertiesl

1．创建mybatis 核心配置文件sqlMapConfig.xml

2．创建数据库连接属性文件 db.properties数据库中的driver url user password

3．数据库连接池:

提供固定数量的连接放入连接池，当需要使用数据库连接时从连接池中获取，自动关闭资源释放内存

1. id="getDeptByDeptno”接口的方法名Ⅰ

2. parameterType="java.lang.Integer”参数的数据类型3. resultType="com.neuedu.bean.Dept”查询结果的数据类型数据库事务∶

1．使用提交(COMMIT)命令实现:确认也就是使DML操作生效2．使用回滚(ROLLBACK)命令实现:取消也就是使DML操作失效

数据库loc     bean location

1.将数据库列名加列别名改为bean的名字

2、配置Dept封装 映射   resultMap

  < select id= "getDeptAll" resultMap= "DeptResult" >

     select * from dept

  select >

property 封装类的属性  column 列名

  < resultMap type= "mybatis.bean.Dept" id= "DeptResult" >

      < result property= "loction" column= "loc" />

  resultMap >

association去关联另一张表

property="Dept" EMP封装类中的 Dept属性名字(区分大小写)

javaType导入的封装类型com.neuedu. bean. DeptI

column两张表关联的外键|

open开始的字符

close结束的字符

separator分隔符字符，-->

    #{item}

开启工级缓存后该事务的数据将会存储到mybatis的缓存中,方便下一次读取

    

    

< / settings>

Mybatis提供 查询缓存，如果缓存中有数据就不用从数据库中获取，用于减轻数据压力，提高系统性能。Mybatis的查询缓存总共有两级，我们称之为—级缓存和二级缓存。

一级缓存是SqISession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构(HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域(HashMap）是互相不影响的。

二级缓存是Mapper (namespace)级别的缓存。多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

#与$占位符的特点

1.MyBatis处理#{}占位符，使用的JDBC对象是PreparedStatement对象，执行sql语句的效率更高。

2.使用PreparedStatement对象，能够避免 sql注入，使得sql语句的执行更加安全。

3.#{}常常作为列值使用，位于sql语句中等号的右侧;#{}位置的值与数据类型是相关的。

$占位符的特点

MyBatis处理$(}占位符，使用的JDBC对象是Statement对象，执行sql语句的效率相对于#}占位符要更低。2.$(}占位符的值，使用的是字符串连接的方式，有sql注入的风险，同时也存在代码安全的问题。

4.$}占位符中的数据是原模原样的，不会区分数据类型。

5.${}占位符常用作表名或列名，这里推荐在能保证数据安全的情况下使用${}。

注意:Statement对象是PreparedStatement对象父接口

PreparedStatement对象可以使用占位符?statement不可以sql 注入: 

Select *from emp where pass word= ' hh123'

pass word=" hh123'错误的

select *from emp where pass word='hh123 or 1=1'

Maven

Maven是什么

Maven的本质是一个项目管理工具，将项目开发和管理过程抽象成一个项目对象模型(POM)

POM (Project Object Model):项目对象模型

Maven是跨平台的项目管理工具。

主要服务于基于Java平台的项目构建，依赖管理和项目信息管理。是apache的一个顶级开源项目。 Maven基于约定优于配置的原则: 即使用 最佳实践，减少配置。

Maven项目的优点:

1．依赖管理: 依赖管理指的就是使用Maven来管理项目中使用到的jar包。Maven管理的方式就是：自动下载项目所需要的jar包，统一管理jar包之间的依赖关系。

2．项目构建: 

理想的项目构建是高度自动化，跨平台，可重用的组件，标准化的，使用maven就可以帮我们完成上述所说的项目构建过程。

1、本地仓库存放从中央仓库下载的依赖组件。所有jar包的本机位置:默认地址: 

C: \user\xxx.m2\repository

2、远程仓库中央仓库: central repository (由Apache官方维护的组件库，组件可升级)私有仓库(私服)︰机构自己搭建的远程仓库(适用于本机构内部各个项目组使用)第三方公共库:比如国内阿里Maven镜像仓库

Maven坐标

Maven通过坐标对jar包进行唯一标识。坐标通过3个元素进行定义，groupld、artifactld、version。

1. groupld:组织标识，一般为域名倒置。

2. artifactld:项目名或模块名，是当前项目中的唯一标识。

3. version:当前项目版本。

Spring

Spring程序开发步骤

导入Spring开发的基本包坐标

编写Dao接口和实现类

创建Spring核心配置文件

在Spring配置文件中配置UserDaolmpl

使用Spring的API获得Bean 实例

六大模块：

核心容器(Core Container)   依赖注入与控制反转（Spring IOC）

AOP (Aspect Oriented Programming)   面向切面编程 （Spring AOP）

设备支持(Instrmentation)

数据访问及集成(Data Access/Integeration)

Web报文发送(Messaging)

Test测试

Spring两大核心

DI:依赖注入(Dependency lnjection)AOP:面向切面编程(Aspect Oriented Programming)

Spring框架：

    1、依赖注入：去除组件之间的依赖关系，实现解耦合。 也就是说：所谓依赖注入，是指工程中需要的组件无须自己创建，而是依赖于外部环境注入。

    2、Spring实现依赖注入有三种方式：

         注解方式（官方推荐方式）、xml配置文件方式、javaConfig方式。

                             

1.Spring配置文件就相当于一个容器。此容器中负责创建对象，并实现对象与对象之间的装配。

2. java中每一个类都是一个bean。所以上面的bean标签，就是在容器中创建一个java对象。

3. bean标签中的class属性，就是类名;id属性，就是对象名。

4. property标签，是给bean的属性注入其它对象。name属性，就是对象属性名;ref属性，就是给

属性注入的对象。(如果想要注入基本数据类型，那么使用value属性)

5.给bean的属性注入其它对象，默认使用get/set方法注入。也可以使用其它方式注入∶构造方法

注入、P命名空间注入等。

当 scope的取值为 singleton时

Bean的实例化个数:1个

Bean的实例化时机:当Spring核心文件被加载时，实例化配置的Bean实例

Bean的生命周期:

对象创建:当应用加载，创建容器时，对象就被创建了

对象运行:只要容器在，对象一直活着

对象销毁:当应用卸载，销毁容器时，对象就被销毁了

当 scope的取值为 prototype时

Bean的实例化个数:多个

Bean的实例化时机:当调用getBean()方法时实例化Bean

对象创建:当使用对象时，创建新的对象实例

对象运行:只要对象在使用中，就一直活着

对象销毁:当对象长时间不用时，被Java的垃圾回收器回收了

init-method:指定类中的初始化方法名称

destroy-method:指定类中销毁方法名称

Bean实例化三种方式

无参构造方法实例化

工厂静态方法实例化

工厂实例方法实例化

Bean的依赖注入方式

怎么将UserDao怎样注入到UserService内部呢?

构造方法

set方法

注入数据的三种数据类型

普通数据类型

引用数据类型

集合数据类型

 

注解：

@Component：创建此类的对象，并放入到Spring容器中。 @Component("xxxx")：创建此类的对象，取一个对象名，并放入到Spring容器中。

@Component这个泛指组件的注解外，Spring还提供了与@Component功能相同的三个语义化注解。

1.@Service 业务层组件

2.@Controller控制层组件

3.@Repository 数据层组件

@Autowired // 省略get set

 

IOC与Dl

IOC:控制反转(Inversion of Control):它是一种控制权的转移。即组件与组件之间的依赖由主动变为被动。也就是说:应用程序本身不再负责组件的创建、维护等，而是将控制权移交出去。从这一点

来说，几乎所有的框架都是IOC框架。

DI:依赖注入(Dependency Injection)︰依赖其他容器(比如spring）来创建和维护所需要的组件，并将其注入到应用程序中。 

IOC只是将组件控制权移交出去，但并没有说明组件如何获取。而DI明确说明:组件依赖Spring容器

获取。所以可以这样说:DI是IOC思想的一种具体实现。

Spring框架:可以帮助程序员去管理dao层service层 bean层(Model层) controller(控制层）

AOP（面向切面）：

作用：把程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

业务逻辑：项目的主要功能模块

方面代码：辅助功能模块（日志、异常处理、事务、输入验证、安全等等）

1.@Aspect注解:定义此类为方面代码，即是一个通知。

2.@Before注解:定义一个前置通知。即在目标方法执行前切入此注解标注的方法。

3. execution()是一个Aspect表达式，语法为: execution(返回值类型包名.类名.方法名(参数)异常)

* 例如：execution(* com.neusoft.service.impl.*.*(..))

* 第一个 *：所有的返回值类型

* 第二个 *：所有的类

* 第三个 *：所有的方法

* 第四个 .. ：所有的参数

方面代码一般也称为通知:定义一个“切面”要实现的功能。通知有五种:

1．前置通知:在某连接点(JoinPoint就是要织入的业务方法）之前执行的通知

2．后置通知:当某连接点退出时执行的通知(不论是正常结束还是发生异常)

3．返回通知:(最终通知)在这里可以得到业务方法的返回值。但在发生异常时无法得到返回值。

4．环绕通知:包围一个连接点的通知，也就是在业务方法执行前和执行后执行的通知。

5．异常通知:在业务方法发生异常时执行的通知。

Spring集成Mybatis：

Spring为了支持事务管理，专门封装了事务管理对象。我们只要在Spring容器中配置这个对象，即可使用。

在Sprina容哭中添加事务管理的配置

注意:

1.需要事务管理的service，在方法上加上@Transactional注解即可。

2.必须为public方法才行,不要捕捉异常，要让异常自动抛出，否则不能进行事务回滚。

事务传播行为

@Transactional注解中的propagation属性，可以设置事务传播行为。属性值为:

1.如果当前没有事务，就新建一个事务，如果已经存在一个事务中，就加入到这个事务中。这是最常见的选择。

2.SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行。

3.MANDATORY:使用当前的事务，如果当前没有事务，就抛出异常。

4.REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起。

5.NOT_SUPPORTED:以非事务方式执行操作，如果存在事务，就把当前事务挂起。

6.NEVER:以非事务方式执行，如果当前存在事务，则抛出异常。

SpringMVC框架

Spring MVC是Spring 提供给Web应用的框架设计。

Spring MVC角色划分清晰，分工明细，并且和Spring框架无缝结合。

注意:

"/”与"/*”与"/**”的区别"/"拦截所有，但不包括html、isp.等。

"/*"”真正的拦截所有，包括所有后缀。但只匹配一级，即/add , /query等

"/**"拦截所有，包括所有后缀。但匹配多级，即/add/user...等

需求:客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转

开发步骤:

导入SpringMVC相关坐标

配置SpringMVC核心控制器DispathcerServlet

创建Controller类和视图页面

使用注解配置Controller类中业务方法的映射地址

配置SpringMVC核心文件spring-mvc.xml

客户端发起请求测试

SpringMVC：注解

@Controller:此注解声明在类上，表示此类是一个Handler处理器类，并被纳入到Spring容器中;

@ResponseBody:此注解可以声明在类上，或者方法上;表示处理器方法直接返回数据。

@RequestMapping:此注解可以声明在类上，或者方法上;表示将一个请求url映射给处理器方法。

@ResponseBody注解的作用是将controller的方法返回的数据写入到response对象的body区，也就是直接将数据写入到输出流中，效果等同于使用response.getWriter()输出流对象向前端返回数据。需要注意的是，在使用此注解之后，响应不会再走视图处理器。

1.@ResponseBody应用在处理器类上:此处理器类中的所有方法都直接返回数据。

2.@ResponseBody应用在处理器类的某个方法上:此处理器类中的某个方法直接返回数据。

@RequestMapping

用于建立请求URL和处理器方法之间的对应关系。

@RequestMapping应用在处理器类上:设置请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以/开头。它出现的目的是为了使我们的URL可以按照模块化管理。

@RequestMapping 应用在处理器类的某个方法上:请求URL的第二级访问目录。

@RequestMapping注解中常用属性有:

value:用于指定请求的URL。method:用于指定请求的方式。

@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。 @PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写。

@RestController:  @ResponseBody+@Controller

注意:只要SpringWVC 的处理器返回值设置为对象，或者集合，那么就能返回json 数据。

user    list  -----  json    array

SpringMVC 文件上传：

    1、导入相关坐标 commons-fileupload文件上传 commons-io流

    2、配置文件中配置文件上传解析器

    3、MultipartFile myFile

拦截器与过滤器的区别

1. Filter是Servlet容器的，Interceptor是SpringMvc实现的(结合springBoot看)

2.Filter对所有请求起作用,Intercptor可以设置拦截规则，而且只对经过DispatchServlet的请求起作

用。

3.Filter只能拿到request和response，interceptor可以拿到整个请求上下文，包括request和

response。

4. Filter是基于函数回调，Interceptor是基于反射(AOP思想)

SSM集成分析

简单来说:SSM集成就是使用Spring给SpringMVC和MyBatis注入所需要组件。具体来说:SSM集成就是:

1.由SpringMVC负责搭建MVC架构，由MyBatis负责持久层。

2.由Spring给SpringMVC注入控制层组件、业务层组件、数据层组件等。

3.由Spring 给MyBatis注入数据源、SqlSessionFactory、事务等。

SpringBoot

SpringBoot提供了一种快速开发Spring项目的方式，而不是对Spring功能上的增强。

Spring的缺点:

    配置繁琐

    依赖繁琐

SpringBoot功能:

    自动配置

    起步依赖:依赖传递

    辅助功能

1、创建独立Spring应用

2、内嵌web服务器

3、自动starter依赖，简化构建配置

4、自动配置Spring以及第三方功能

5、提供生产级别的监控、健康检查以及外部优化配置

6、无代码生成、无需编写XML

一句话概括：

 SpringBoot是整合Spring的一站式框架

 SpringBoot是简化Spring技术栈的快速开发脚手架

1)自动配置

Spring Boot的自动配置是一个运行时(更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2)起步依赖

起步依赖本质上是一个Maven项目对象模型(Project Object Model，POM)，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3)辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

Spring Boot并不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式。

创建Maven项目：

导入SpringBoot

起步依赖

定义Controller

编写引导类启动测试

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

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

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

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

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

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

约定大于配置

配置文件分类

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml (application.yaml）进行配置。

SpringBoot提供了2种配置文件类型:properteis和ym  yaml

默认配置文件名称: application

在同一级目录下优先级为: properties > yml > yaml

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

YAML:基本语法

大小写敏感

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

使用缩进表示层级关系

缩进时不允许使用Tab键，只允许使用空格（(各个系统Tab对应的空格数目可能不同，导致层次混乱)。缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

#表示注释，从这个字符一直到行尾，都会被解析器忽略。

server:

    port: 8080

    address : 127.0.0.1

name: abc

对象(map)︰键值对的集合。

person :

    name : zhangsan

    #行内写法

    person : {name: zhangsan}

数组:一组按次序排列的值

address:

    - beijing

    - shanghai

    #行内写法

address:[beijing, shanghai]

纯量:单个的、不可再分的值

msg1 : 'hello \n world'  #单引忽略转义字符

msg2 : "hello \n world"#双引识别转义字符

参数引用：${ }

读取配置内容

1)@Value

2) Environment

3)@ConfigurationProperties

profile

我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如:开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。

1) profile配置方式

多profile文件方式yml多 文档方式

2) profile激活方式

配置文件虚拟机参数命令行参数

spring.profiles.active=pro

Profile-小结

1) profile是用来完成不同环境下，配置动态切换功能的。

2) profile配置方式

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

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

. application-test.properties/yml测试环境. application-pro.properties/yml生产环境yml多文档方式:

在yml中使用---分隔不同配置

3) profile激活方式

配置文件:再配置文件中配置: spring.profiles.active=dev虚拟机参数:在VM options指定:-Dspring.profiles.active=dev命令行参数: java-jar xxx.jar --spring.profiles.active=dev

内部配置加载顺序

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

1. file:./config/:当前项目下的/config目录下

2. le:.︰当前项目的根目录

3. classpath:/config/: classpath的/config目录

4. classpath:/ : classpath的根目录

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

结论: springboot所有自动配置都是在启动的时候扫描并加载:

spring.factories所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了对应的start，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功!