二度理解Java web中的核心知识

一、xml

1、什么是xml

XML是一种可扩展的标记语言，可扩展就是<>内的东西可以自己定义，可以随便写。标记语言就是加了<>符号的。HTML是超文本标记语言，不可以拓展，因为你写个

浏览器知道这个是段落，你写个浏览器就不认识了，所以不可拓展。

同时XML 被设计用来传输和存储数据的，通过解析xml可以获得里面的数据。跟Json类似

2、xml的语法（书写格式）

1.开头固定

2.只能有一个根元素

3.没了

<?xml version="1.0" encoding="UTF-8"?>
<Students><student><name>许嵩</name><age>32</age></student><student><name>蜀云泉</name><age>23</age></student>
</Students>

那为什么java常见的xml配置文件头部有很多约束（命名空间）

举例 maven的配置文件pom.xml

当你使用约束以外的其他标签时：

我们把约束都删除后：

java里面的配置文件，肯定是有约束的。因为你使用别人的框架，就必须遵守规则。（约定大于配置）
也可以这样理解，每一种配置文件xml，都已近写好了解析xml的代码，如果你不按照约束来编写xml，在解析过程中就会出错。

3、解析xml

private File f=new File("F:/Study Java/ch1helloworld/src/main/java/com/StadyJava/day2/xmldemo.xml");public void testDocument() throws ParserConfigurationException, IOException, SAXException {//1.DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();//2.DocumentBuilder builder=factory.newDocumentBuilder();//3 经过这3步获取到了文档Document doc=builder.parse(f);//上面的三步可以写成这样//Document doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(f);//已经获取了文档对象，现在获取xml的根元素Element root=doc.getDocumentElement();//获取第二个student 因为返回的是父类型Node,所以需要强转一下Element student2=(Element) root.getElementsByTagName("student").item(1);//获取第二个student元素的子元素nameElement name2=(Element) student2.getElementsByTagName("name").item(0);//获取name元素的文本内容System.out.println(name2.getTextContent());}

参考：Java中的XML

二、web.xml

1、web.xml加载过程

web.xml 的加载顺序是：context- param -> listener -> filter -> servlet（也代表了监听器、过滤器、servlet的执行顺序）

容器首先会去它的配置文件web.xml读取两个节点: < listener>< /listener>和< context-param>< /context-param>。
紧接着，容器创建一个ServletContext（Application），这个WEB项目所有部分都将共享这个上下文。
容器以< context-param></ context-param>的name作为键，value作为值，将其转化为键值对，存入ServletContext。
容器创建< listener></ listener>中的类实例，根据配置的class类路径< listener-class>来创建监听，在监听中会有contextInitialized(ServletContextEvent args)初始化方法，启动Web应用时，系统调用Listener的该方法，在这个方法中获得：ServletContext application = ServletContextEvent.getServletContext(); context-param的值 = application.getInitParameter(“context-param的键”); 得到这个context-param的值之后，你就可以做一些操作了。
举例：你可能想在项目启动之前就打开数据库，那么这里就可以在< context-param>中设置数据库的连接方式（驱动、url、user、password），在监听类中初始化数据库的连接。这个监听是自己写的一个类，除了初始化方法，它还有销毁方法，用于关闭应用前释放资源。比如:说数据库连接的关闭，此时，调用contextDestroyed(ServletContextEvent args)，关闭Web应用时，系统调用Listener的该方法。
接着，容器会读取< filter></ filter>，根据指定的类路径来实例化过滤器。
以上都是在WEB项目还没有完全启动起来的时候就已经完成了的工作。如果系统中有Servlet，则Servlet是在第一次发起请求的时候被实例化的，而且一般不会被容器销毁，它可以服务于多个用户的请求。所以，Servlet的初始化都要比上面提到的那几个要迟。
总的来说，web.xml的加载顺序是:< context-param>->< listener>->< filter>->< servlet>。其中，如果web.xml中出现了相同的元素，则按照在配置文件中出现的先后顺序来加载。

参考：Web.xml详解

整合ssm时的web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"version="4.0"><!--    全局初始化参数--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><!--    配置监听器--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><!--1.注册servlet--><servlet><servlet-name>SpringMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!--通过初始化参数指定SpringMVC配置文件的位置，进行关联--><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc.xml</param-value></init-param><!-- 启动顺序，数字越小，启动越早 --><load-on-startup>1</load-on-startup></servlet><!--所有请求都会被springmvc拦截 --><servlet-mapping><servlet-name>SpringMVC</servlet-name><url-pattern>/</url-pattern></servlet-mapping>
</web-app>

三、监听器、过滤器、拦截器

一些概念：

servlet 流程是短的，url传来之后，就对其进行处理，之后返回或转向到某一自己指定的页面。它主要用来在业务处理之前进行控制.
filter 流程是线性的， url传来之后，检查之后，可保持原来的流程继续向下执行，被下一个filter, servlet接收等，而servlet 处理之后，不会继续向下传递。filter功能可用来保持流程继续按照原来的方式进行下去，或者主导流程，而servlet的功能主要用来主导流程。filter可用来进行字符编码的过滤，检测用户是否登陆的过滤，禁止页面缓存等
servlet,filter都是针对url之类的，而listener是针对对象的操作的，如session的创建，session.setAttribute的发生，在这样的事件发生时做一些事情。

Filter与Servle:

Filter可认为是Servle的一种加强版，主要用于对用户请求request进行预处理，也可以对Response进行后处理，是个典型的处理链。使用Filter的完整流程是：Filter对用户请求进行预处理，接着将请求HttpServletRequest交给Servlet进行处理并生成响应，最后Filter再对服务器响应HttpServletResponse进行后处理。

过滤器与拦截器：

过滤器可以修改request，而拦截器不能
拦截器可以调用IOC容器中的各种依赖，而过滤器不能。
过滤器需要在servlet容器中实现，拦截器可以适用于javaEE，javaSE等各种环境。
过滤器只能在请求的前后使用，而拦截器可以详细到每个方法。

过滤器（Filter）：可以拿到原始的http请求，但是拿不到你请求的控制器和请求控制器中的方法的信息。
拦截器（Interceptor）：可以拿到你请求的控制器和方法，却拿不到请求方法的参数。

过滤器和拦截器的区别：

Filter是基于函数回调的，而Interceptor则是基于Java反射的。
Filter依赖于Servlet容器，而Interceptor不依赖于Servlet容器。
Filter对几乎所有的请求起作用，而Interceptor只能对action请求起作用。
Interceptor可以访问Action的上下文，值栈里的对象，而Filter不能。
在action的生命周期里，Interceptor可以被多次调用，而Filter只能在容器初始化时调用一次。
如果要实现登录拦截：推荐使用拦截器。（在可以使用拦截器时优先使用拦截器）

执行顺序：
listener （监听器）-> filter（过滤器） -> Interceptor（拦截器）-> servlet

1、监听器

监听器的主要的作用：做一些初始化的内容添加工作、设置一些基本的内容、比如，一些参数或者是一些固定的对象等等。下面利用监听器对数据库连接池DataSource的初始化演示它的使用。

像ssm框架整合的时候。我们就将spring容器的ApplicationContext通过监听器初始化到ServletContext域中。这样在访问任何的controller（控制层时）我们就可以使用spring 容器注入service（业务层）的操作对象了。

举例1

package com.lihua.ssm.controller;import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;/**** web监听器* @author 15594*/
public class  MyServletContextListener implements ServletContextListener {//初始化public void contextInitialized(ServletContextEvent servletContextEvent) {//通过这个容器域获取web.xml中的context-param数据ServletContext servletContext = servletContextEvent.getServletContext();//在web应用启动前，创建好一些对象和数据String s = new String("123");System.out.println("初始化完成！");}//销毁public void contextDestroyed(ServletContextEvent servletContextEvent) {//Servlet容器最大的域ServletContext servletContext = servletContextEvent.getServletContext();servletContext.removeAttribute("dataSource");System.out.println("销毁工作完成");}
}

 <!--自己配置一个监听器，初始化数据对象-->
<listener><listener-class>com.lihua.ssm.controller.MyServletContextListener</listener-class>
</listener>

举例2 ssm中使用到的监听器

当我们单独使用spring 时需要经过下面这一步

//加载applicationContext.xml 获得操作spring 容器的对象context
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//通过容器获得一个bean userService
IUserService userService = (IUserService) context.getBean("userService");

使用监听器我们就可以省略这一步。我们需要这样配置监听器。

package com.lihua.ssm.listener;import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;/*** 监听器，初始化spring容器，并将容器操作对象放到ServletContext域中，使得web应用全局都能使用spring 容器** @author 15594*/
public class MyContextLoaderListener implements ServletContextListener {public void contextInitialized(ServletContextEvent servletContextEvent) {ServletContext servletContext = servletContextEvent.getServletContext();//获取web.xml中配置的applicationContext.xml的名字String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation1");//加载applicationContext.xml 获得操作spring 容器的对象context//ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");ApplicationContext context = new ClassPathXmlApplicationContext(contextConfigLocation);servletContext.setAttribute("context",context);System.out.println("spring 容器创建完成");}public void contextDestroyed(ServletContextEvent servletContextEvent) {}
}

<!--全局初始化参数：指定要加载的配置文件的名称--><context-param><param-name>contextConfigLocation1</param-name><param-value>applicationContext.xml</param-value></context-param><!--配置监听器，将spring 容器初始化（这个监听器是我们模仿官方自己写的 ,这个监听器的实现与官方不一样，少了许多内容）--><listener><listener-class>com.lihua.ssm.controller.MyServletContextListener</listener-class></listener>

配置了监听器后我们就可以通过下面的方式获取spring 容器的bean

ApplicationContext app = (ApplicationContext)servletContext.getAttribute("context");
UserService userService = app.getBean(UserService.class);

当然，我们如果使用官方提供的监听器创建spring 容器。就不需要这么麻烦了。我们只需要使用两个注解就能实现

2、过滤器

2.1、过滤器的代码实现：

spring boot实现过滤器和拦截器

2.2、过滤器常见的应用场合

Servlet里有request和response两个对象，Filter能够在一个request到达Servlet之前预处理request，也可以在离开Servlet时处理response，Filter其实是一个Servlet链。以下是Filter的一些常见应用场合:

认证Filter
日志和审核Filter
图片转换Filter
数据压缩Filter
密码Filter
令牌Filter
触发资源访问事件的Filter
XSLT Filter
媒体类型链Filter

<!--****************************过滤器配置*********************************-->
<!-- 字符集过滤器 -->
<filter><filter-name>CharacterEncodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param>
</filter>
<!-- 单点登出过滤器 -->
<filter><filter-name>CAS Single Sign Out Filter</filter-name><filter-class>com.yonyou.mcloud.cas.client.session.SingleSignOutFilter</filter-class>
</filter>
<!-- 认证过滤器 -->
<filter><filter-name>CAS Authentication Filter</filter-name><filter-class>com.yonyou.mcloud.cas.client.authentication.ExpandAuthenticationFilter</filter-class><init-param><param-name>casServerLoginUrl</param-name><param-value>https://dev.yonyou.com:443/sso-server/login</param-value></init-param><init-param><!--这里的server是服务端的IP --><param-name>serverName</param-name><param-value>http://10.1.215.40:80</param-value></init-param>
</filter>
<!-- 验证ST/PT过滤器 -->
<filter><filter-name>CAS Validation Filter</filter-name><filter-class>org.jasig.cas.client.validation.Cas20ProxyReceivingTicketValidationFilter</filter-class><init-param><param-name>casServerUrlPrefix</param-name><param-value>https://dev.yonyou.com:443/sso-server</param-value></init-param><init-param><param-name>serverName</param-name><param-value>http://10.1.215.40:80</param-value></init-param><init-param><param-name>proxyCallbackUrl</param-name><param-value>https://dev.yonyou.com:443/business/proxyCallback</param-value></init-param><init-param><param-name>proxyReceptorUrl</param-name><param-value>/proxyCallback</param-value></init-param><init-param><param-name>proxyGrantingTicketStorageClass</param-name><param-value>com.yonyou.mcloud.cas.client.proxy.MemcachedBackedProxyGrantingTicketStorageImpl</param-value></init-param><!-- 解决中文问题 --><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param>
</filter>
<filter><filter-name>CAS HttpServletRequest Wrapper Filter</filter-name><filter-class>org.jasig.cas.client.util.HttpServletRequestWrapperFilter</filter-class>
</filter>
<filter><filter-name>CAS Assertion Thread Local Filter</filter-name><filter-class>org.jasig.cas.client.util.AssertionThreadLocalFilter</filter-class>
</filter>
<filter><filter-name>NoCache Filter</filter-name><filter-class>com.yonyou.mcloud.cas.client.authentication.NoCacheFilter</filter-class>
</filter>
<!--****************************映射关系配置********************************-->
<filter-mapping><filter-name>CharacterEncodingFilter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>NoCache Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS Single Sign Out Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS Validation Filter</filter-name><url-pattern>/proxyCallback</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS Authentication Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS Validation Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS HttpServletRequest Wrapper Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping><filter-name>CAS Assertion Thread Local Filter</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>

参考：Web.xml详解

3、拦截器

这篇文章讲的很详细

3.1、实现拦截器的方式有

SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在SpringMVC 中定义一个Interceptor 非常简单，主要有两种方式：
第一种方式是要定义的Interceptor类要实现了Spring 的HandlerInterceptor 接口，或者是这个类继承实现了HandlerInterceptor 接口的类，比如Spring 已经提供的实现了HandlerInterceptor 接口的抽象类HandlerInterceptorAdapter ；

第二种方式是实现Spring的WebRequestInterceptor接口，或者是继承实现了WebRequestInterceptor的类。

3.2、具体实现代码

在spring mvc中实现拦截器：

拦截后怎么处理（拦截处理器）

package com.lihua.ssm.handler;import com.lihua.ssm.pojo.SysUser;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;/*** * 拦截后怎么处理（拦截处理器）* @author 15594*/
public class LoginInterceptor implements HandlerInterceptor {public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {SysUser loginUser = (SysUser)request.getSession().getAttribute("loginUser");if (loginUser==null){response.sendRedirect("/goLogin");return false;}return true;}public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
}

配置springmvc.xml

<!-- 配置拦截器：mvc:interceptor：定义一个拦截器mvc:mapping：定义需要被拦截的路径mvc:exclude-mapping：定义需要排除拦截的请求路径(放行路径)bean class：指定拦截器对象
--><!-- 配置拦截器 -->
<mvc:interceptors><mvc:interceptor><mvc:mapping path="/**"/><mvc:exclude-mapping path="/css/**"/><mvc:exclude-mapping path="/js/**"/><mvc:exclude-mapping path="/images/**"/><mvc:exclude-mapping path="/goLogin"/><mvc:exclude-mapping path="/userLogin"/><!-- 拦截处理器  --><bean class="com.lihua.ssm.handler.LoginInterceptor"/></mvc:interceptor><!-- 当然我们也可以配置多个拦截器  --><mvc:interceptor><mvc:mapping path="/**"/><mvc:exclude-mapping path="/css/**"/><mvc:exclude-mapping path="/js/**"/><mvc:exclude-mapping path="/images/**"/><mvc:exclude-mapping path="/goLogin"/><mvc:exclude-mapping path="/userLogin"/><!-- 拦截处理器  --><bean class="com.lihua.ssm.handler.LoginInterceptor"/></mvc:interceptor>
</mvc:interceptors>

在spring boot中实现拦截器： (其实实现过程是一样的，因为spring boot 屏弃掉了xml配置文件，所有我们将spring mvc.xml 改成java config 即可 )

拦截处理器

package com.lihua.newideas.handler;import com.lihua.newideas.pojo.MyUser;
import com.lihua.newideas.service.MyUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.User;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;/*
* 主页拦截器
* */
@Component
public class IndexInterceptorHandler implements HandlerInterceptor {@Autowiredprivate MyUserService userService;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//        System.out.println(">>>MyInterceptor2>>>>>>>在请求处理之前进行调用（Controller方法调用之前）");User user = (User) request.getSession().getAttribute("user");if(user!=null){String userName = user.getUsername();MyUser myUser = userService.queryUserByName(userName);if (myUser!=null){myUser.setPassWord("");
//                System.out.println(myUser.toString());request.getSession().setAttribute("MyUser",myUser);}}return true; // 只有返回true才会继续向下执行，返回false取消当前请求}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {//        System.out.println(">>>MyInterceptor2>>>>>>>请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)throws Exception {//        System.out.println(">>>MyInterceptor2>>>>>>>在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");}
}

配置拦截器（就也是将spring mvc.xml中的配置用java config 来配置）

package com.lihua.newideas.config;import com.lihua.newideas.handler.AdminInterceptorHandler;
import com.lihua.newideas.handler.IndexInterceptorHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;/*** 配置拦截器* @author 15594*/
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {/*** 主页处理器* */@Autowiredprivate IndexInterceptorHandler indexInterceptorHandler;/*** 管理员拦截器* */@Autowiredprivate AdminInterceptorHandler adminInterceptorHandler;/*** 当访问静态资源（图片）时* 将http://localhost:8080/upload/2021/6/fields20210618104946523_small.png 请求拦截下来* 换成其他请求路径* */@Overridepublic void addResourceHandlers(ResourceHandlerRegistry registry) {// 通过addResourceHandler添加资源映射路径，然后通过addResourceLocations来指定路径。可以访问自定义upload文件夹registry.addResourceHandler("/upload/admin/**").addResourceLocations("classpath:/upload/admin/").addResourceLocations("file:///" + System.getProperties().getProperty("user.home") + "/newIdeasFile/upload/admin/");registry.addResourceHandler("/upload/user/**").addResourceLocations("classpath:/upload/user/").addResourceLocations("file:///" + System.getProperties().getProperty("user.home") + "/newIdeasFile/upload/user/");WebMvcConfigurer.super.addResourceHandlers(registry);}/*** 自定义处理器的拦截器* 主页拦截器,获取用户个人信息* 多个拦截器组成一个拦截器链* addPathPatterns 用于添加拦截规则* excludePathPatterns 用户排除拦截**/@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(indexInterceptorHandler).addPathPatterns("/");registry.addInterceptor(adminInterceptorHandler).addPathPatterns("/admin");}}

四、Cookie和Session

参考：Cookie和Session
我们知道session的意思就是会话，Cookie和Session 是两种会话技术。通过Cookie和Session 可以实现有状态会话（也就是记住上次用户的一些操作，比如10天免登录）
有状态会话建立在客户端（cookie）和服务端（seesion）