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);
//获取写入流
out = response.getWriter()
out.println();
out.flush(); //刷
//关闭响应输出流
out.close();//自动调用flush
//JSON转换
ObjectMapper om = new ObjectMapper();
//转成JSON
om .writeValueAsString(数组、对象。。。 )
// request.getCookies() 返回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{
<foreach collection="array" item="id" separator="," open="(" close=")">
#{id}
</foreach>
}
<!-- resultMap最终还是要将结果映射到pojo上，type就是指定映射到哪一个pojo --> <!-- id：设置ResultMap的id -->
<!-- 手动映射
column：数据表的字段名
property：java中实体类的属性
-->
<resultMap type="Student" id="Student_Class_Map">
<result column="sid" property="sid"/>
<result column="sname" property="sname"/>
<association property="bj">
<result column="classid" property="classid"/>
<result column="classname" property="classname"/>
</association>
</resultMap>
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操作失效
<!--查询所有
返回值为多条存入集合写集合中存放元素类型
查询时结果集映射查询的对象查到对象后再传入list-->
<! --如果数据库的列字段与bean的名字不一致?
数据库loc bean location
1.将数据库列名加列别名改为bean的名字
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分隔符字符，-->
<foreach collection="array" item="item" open="(" close=")" separator="," >
#{item}
</foreach>
开启工级缓存后该事务的数据将会存储到mybatis的缓存中,方便下一次读取
<!--开启二级缓存--><settings>
<! --参考w3cschool -->
<setting name="cacheEnabled" value="true" />
< / 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命名空间注入等。
<bean>
当 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 文件上传：
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，就有对应的启动器了，有了启动器，我们自动装配就会生效，然后就配置成功!
