关键词：
目录
SpringMVC基本架构
mvc是一种软件设计典范，用一种业务逻辑、数据、界面显示分层， 分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。
Java领域典型的MVC实现及框架:
- Servlet + jsp Servlet是曾经唯一的Java Web编程规范，现在出现了竞争者 Reactive
- 为尽量少依赖servlet api，提高可测试性、可复用性而发展的:
- Struts1 Struts2已成历史
- SpringMVc当下最流行的MVC框架，依托spring框架带来的强大开发便利性。
- Struts2的请求是映射到Action类级别的，每个请求创建一个Action类的实例来处理。
- SpringMVC也支持这种方式，请求映射到实现了Controller接口的bean，但要求Controller Bean 是单例的、线程安全的。这种方式很少被采用。因为有更好的方式:请求映射到Bean的方法（方法级别的映射），这样一个类中可以处理多种请求，大大减少控制器类的数量，同时方法级更易于保证并发请求的线程安全。
- Struts2将请求的数据绑定到Action类实例的属性;
- SpringMVC则是将请求数据绑定到处理方法的参数。
专门找一个 dispatcher进行分发请求，返回不同的view 呈现 到页面上去。
MVC是严格的分工协作
- 有四个个重要角色:DispatcherServlet Controller View Model
- DispatcherServlet的工作很繁重，它很重要!
- DispatcherServlet根据什么规则来分发请求给 controller
- DispatcherServelt来负责转发，它又如何知道该怎么转发
实现一个简单的SpringMVC
建立一个maven工程，只需下面的依赖<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>控制层
普通的javaBean来当Controller，在spring中当然希望以spring lOC容器管理的Bean来当Controller,这样可以很好地利用springloC、aop的功能! 请求如何与Bean对应，在springmvc的设计过程中 也需要考虑这个问题 两种方式 方式一:实例级别的映射 方式二∶方法级别的映射 其实类级别的映射 确实 不适合，就返回了 Struts2的 的模式 了 。方式一:实例级别的映射
映射的规则
- 请求地址与Bean的名称对应: Bean以请求地址为BeanNane或别名;
- 做Controller的Bean实现Controller接口（如下)，这样就知道该调用哪个方法了
才能知道 是映射到那个bean上面的属性上面
Controller处理的结果数据，以及它对应的View 返回的数据 可能是java 对象或者 view 页面。
数据多样化(未知的)，被下一个处理者或view使用。
返回的结果如何存放可方便view使用
通过map 进行存储 而view是
多种多样，但是都是向浏览器做出响应的，响应的内容不同。
最后定义出来的 类型 包括view 页面的存储 地方。 请求处理过后 就是 一个modelandview.
public interface View
void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response);
public interface Controller
ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
方式二:方法级别的映射
定义的规则：
- 普通的Bean(不需要实现Controller接口)做ontroller;
- 请求映射到Bean的方法
对于请求头 参数 等的参数过滤 这个注解中可以添加上
@Documented
@Retention(RUNTIME)
@Target( TYPE, METHOD )
public @interface RequestMapping
/**
* 給定义的映射关系取个名字。如果类上、方法上都有，以#相连
*/
String name() default "";
/**
* The primary mapping expressed by this annotation.
* <p>
* This is an alias for @link #path. For example
* @code @RequestMapping("/foo") is equivalent to
* @code @RequestMapping(path="/foo").
* <p>
* <b>Supported at the type level as well as at the method level!</b> When
* used at the type level, all method-level mappings inherit this primary
* mapping, narrowing it for a specific handler method.
*/
@AliasFor("path")
String[] value() default ;springmvc对于多种controller方式的支持
怎么扩展分发 请求 到不同的controller上。 映射的方式也不同的 包括请求映射到实例 ，或者 映射到方法上。 并且 请求处理器handler 也是不一样的。
Controller接口实现对象
@Controller、@RequestMapping注解标识的bean的方法
不同的方式，映射规则不一样，请求处理器也不一样 ，而解决 的方式就是采用策略模式去处理
设计不同请求处理分发方式的策略接口:HandlerMapping
将实现者配置为Bean，DispatcherServlet从ApplicationContext中获取所有配置的
在里面添加 order 接口 来排序 对于 不同的处理器上面。 以及 两种实例化的方式映射到不同的controller上去。将实现者配置为Bean，DispatcherServlet从ApplicationContext中获取所有配置的
设计不同Handler执行的适配器接口: HandlerAdapter
1、每种不同的请求处理器提供它的适配实现，配置为Bean
2 、DispatcherServlet从ApplicationContext中获取所有配置的，面向HandlerAdapter，隔绝
Handler的变化影响!
public class RequestMappingInfo
private RequestMapping classRequestMapping;
private String beanName;
private Class<?> beanType;
private RequestMapping methodRequestMapping;
private Method method;
private Object handler;
public RequestMappingInfo(RequestMapping classRequestMapping, String beanName, Class<?> beanType,
RequestMapping methodRequestMapping, Method method)
super();
this.classRequestMapping = classRequestMapping;
this.beanName = beanName;
this.beanType = beanType;
this.methodRequestMapping = methodRequestMapping;
this.method = method;
public boolean match(HttpServletRequest request)
// 1、path 不需要进行匹配了，匹配了path才选择的该Mapper
// 2、 匹配 http Method
if (!this.matchHttpMethod(request))
return false;
// 3、匹配headers
if (!this.matchHeaders(request))
return false;
// 4、匹配params
if (!this.matchParams(request))
return false;
return true;
注解信息的获取，RequestMappingHandlerMapping，在它的实例创建好，初始化后
把注解信息进行加载注解信息。
这里就是生命周期的时候可以进行 读取注解信息 解析开来进行读取。
而这些 类的扫描信息 是asm 字节码 进行获取到原数据的。
我们此时通过ApplicationContext获取Bean的MVC注解信息，是通过原来的 AnnotatedBeanDefinition，还是加载类加载类，通过反射方式获取 MVC注解检测的逻辑@Override
public void afterPropertiesSet() throws Exception
// 检测@Controller Bean
for (String beanName : this.applicationContext.getBeanNamesForType(Object.class))
Class<?> beanType = this.applicationContext.getType(beanName);
if (isHandlerBean(beanType))
detectHandlerMethod(beanType);
这些可以 在 handlermapping 进行处理的 检测并缓存起来的。
并且 要考虑在getHandler(request)阶段能更快速地获取
DispatcherServlet
DispatcherServlet要完成的事情- 1、创建ApplicationContext容器
- 要从容器中获得HandlerMapping、 HandlerAdapter
- 完成分发
- 完成view转发
- 完成异常处理
对于DispatcherServlet要完成这些事情
- 在init方法中完成3个属性的初始化
- 在service方法中完成handler分发、执行的逻辑
- 在destroy方法中关闭applicationContext
public class DispatcherServlet extends HttpServlet
/**
*
*/
private static final long serialVersionUID = -560428787709797085L;
private static final String CONTEXT_CONFIG_LOCATION_PARAM_NAME = "contextConfigLocation";
private static final String ROOT_APPLICATION_CONTEXT_ATTRIBUTE_NAME = "root_application_context";
private static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE_NAME = "web_application_context";
protected final Log logger = LogFactory.getLog(getClass());
private GenericXmlApplicationContext webApplicationContext;
private List<HandlerMapping> handlerMappings;
private List<HandlerAdapter> handlerAdapters;
public void init() throws ServletException
String contextConfigLocation = this.getInitParameter(CONTEXT_CONFIG_LOCATION_PARAM_NAME);
if (StringUtils.isEmpty(contextConfigLocation))
contextConfigLocation = this.getServletContext().getInitParameter(CONTEXT_CONFIG_LOCATION_PARAM_NAME);
if (StringUtils.isEmpty(contextConfigLocation))
throw new ServletException("没有 spring mvc指定[" + CONTEXT_CONFIG_LOCATION_PARAM_NAME + "]参数");
this.webApplicationContext = new GenericXmlApplicationContext();
// 设置它的父容器，如果有放在ServletContext中root容器
this.webApplicationContext.setParent(
(ApplicationContext) this.getServletContext().getAttribute(ROOT_APPLICATION_CONTEXT_ATTRIBUTE_NAME));
// 加载xml Bean定义配置
this.webApplicationContext.load(contextConfigLocation);
// 刷新
this.webApplicationContext.refresh();
// 将webApplicationContext也放入ServletContext中
this.getServletContext().setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE_NAME, webApplicationContext);
// 初始化 MVC相关组件
initStrategies(webApplicationContext);
/**
* 初始化 MVC相关组件的策略提供者，从applicationContext中获取
*
* @param applicationContext
*/
private void initStrategies(ApplicationContext applicationContext)
// 1、initHandlerMapping
initHandlerMappings(applicationContext);
// 2、initHandlerAdapter
initHandlerAdapters(applicationContext);
private void initHandlerAdapters(ApplicationContext applicationContext)
// 查找applicationContext中所有的HandlerMapping类型的Bean
Map<String, HandlerAdapter> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext,
HandlerAdapter.class, true, false);
if (!matchingBeans.isEmpty())
this.handlerAdapters = new ArrayList<>(matchingBeans.values());
if (CollectionUtils.isEmpty(this.handlerAdapters))
// 初始化为默认的
SimpleControllerHandlerAdapter df = new SimpleControllerHandlerAdapter();
this.handlerAdapters = Collections.singletonList(df);
private void initHandlerMappings(ApplicationContext applicationContext)
// 查找applicationContext中所有的HandlerMapping类型的Bean
Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext,
HandlerMapping.class, true, false);
if (!matchingBeans.isEmpty())
this.handlerMappings = new ArrayList<>(matchingBeans.values());
// We keep HandlerMappings in sorted order.
AnnotationAwareOrderComparator.sort(this.handlerMappings);
if (CollectionUtils.isEmpty(this.handlerMappings))
// 初始化为默认的
BeanNameUrlHandlerMapping df = new BeanNameUrlHandlerMapping();
df.setApplicationContext(applicationContext);
this.handlerMappings = Collections.singletonList(df);
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
// 在这里可把一些Dispatcher持有的对象放入到Request中，以被后续处理过程中可能需要使用到
req.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE_NAME, webApplicationContext);
this.doDispatch(req, resp);
private void doDispatch(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
Object handler = null;
ModelAndView mv = null;
Exception dispatchException = null;
try
// 1、获取请求对应的handler
handler = this.getHandler(req);
// 2、如果没有对应的handler
if (handler == null)
noHandlerFound(req, resp);
return;
// 3、如果有对应的handler，获得handler的Adapter
HandlerAdapter ha = this.getHandlerAdapter(handler);
// 4、执行adapter
mv = ha.handle(req, resp, handler);
catch (Exception e)
dispatchException = e;
// 5、转发给view
processDispatchResult(req, resp, handler, mv, dispatchException);
private void processDispatchResult(HttpServletRequest req, HttpServletResponse resp, Object handler,
ModelAndView mv, Exception dispatchException) throws ServletException
// 1、 如果有异常,生成对应的异常视图
if (dispatchException != null)
mv = doProcessException(req, resp, handler, dispatchException);
// 2、渲染视图
render(req, resp, mv);
private ModelAndView doProcessException(HttpServletRequest req, HttpServletResponse resp, Object handler,
Exception dispatchException)
// TODO Auto-generated method stub
return null;
private void render(HttpServletRequest req, HttpServletResponse resp, ModelAndView mv) throws ServletException
// 1、判断MV的view是否是一个viewName，如是转为对应的view
View view;
String viewName = mv.getViewName();
if (viewName != null)
// 将viewName转为对应的view.
view = resolveViewName(viewName, mv.getModel(), req);
if (view == null)
throw new ServletException("Could not resolve view with name '" + mv.getViewName()
+ "' in servlet with name '" + getServletName() + "'");
else
// 是一个真正的view对象
view = mv.getView();
if (view == null)
throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a "
+ "View object in servlet with name '" + getServletName() + "'");
try
if (mv.getStatus() != null)
resp.setStatus(mv.getStatus().value());
view.render(mv.getModel(), req, resp);
catch (Exception ex)
if (logger.isDebugEnabled())
logger.debug("Error rendering view [" + view + "]", ex);
throw ex;
private View resolveViewName(String viewName, Map<String, Object> model, HttpServletRequest req)
// TODO Auto-generated method stub
return null;
private HandlerAdapter getHandlerAdapter(Object handler)
for (HandlerAdapter ha : this.handlerAdapters)
if (ha.supports(handler))
return ha;
return null;
private void noHandlerFound(HttpServletRequest req, HttpServletResponse response) throws IOException
// TODO 如果没有特定的处理规则，就直接404了
response.sendError(HttpServletResponse.SC_NOT_FOUND);
private Object getHandler(HttpServletRequest req) throws Exception
Object handler = null;
for (HandlerMapping hm : this.handlerMappings)
handler = hm.getHandler(req);
if (handler != null)
return handler;
return null;
@Override
public void destroy()
this.webApplicationContext.close();
View
做到灵活的扩展，自动映射的情况。
解决嵌入式的问题。
重新定义ModelAndView
添加视图的名字。加入视图名称，由HandlerAdapter根据handler返回结果来创建
ModelAndView； 需要一个专门处理视图的处理层。 View-ViewResolver ViewResolver完成从视图名到视图的转换。 不同的视图技术可能有不同的View实现及转换规则，那就实现ViewResolver来提供 对应的转换规则，都配置为Bean，DispatcherServlet好从容器中获取!
这里面要做的 包括 对应前端页面的 怎么判断是jsp html 对应的资源，或者 转发 重定向 等等。
这个处理层 一定需要做的。
这里的解决办法 就采用 字符串带前缀:forward:redirect: 来定义第一个实现!
默认就是字符串 其他方式就采用添加前缀来表示。
一个基于URL的转发、重定向的ViewResolver实现
为了方便 返回数据设计Model
而不使用map来存储的并返回也是因为：
Map是一个通用的集合类型，没法在方法参数上区分是否用来返回值的。拦截处理器
对于请求参数 怎么绑定到handler上面去
并且对于请求进行过滤等等。
利用Handlerlnterceptor 来处理这些事情。
HandlerInterceptor接口定义
用户实现它来提供拦截器，可同时实现Ordered接口来指定顺序。
- 用户实现它来提供拦截器，可同时实现Ordered接口或@order来指定顺序
- 在其上加@requestMapping来指定它要过滤的请求
- 配置为Bean
- HandleMapping初始化阶段完成HandlerInterceptor的加载
- 在获取Handler阶段，把拦截器加入，形成链返回
- 执行链
这里都是要经过过滤器进行过滤的。
SpringMVC 源码分析
servlet
se'rvlet 是运行在 Web 服务器或应用服务器上的程序，处理Http请求。Servlet规范目前已经到了4.0，JavaEE8规范，不过3.0后的版本是一个分水岭。
servlet是一个规范，然后在java中的实现。
SpringMVC跟Servlet的关系 而springmvc 则是 在servlet协议下的一个具体实现， 在spring框架下面的一个具体实现。 Tomcat跟Servlet的关系tomcat是web容器，而用来存储 servlet的具体实现。
通信框架与Tomcat、Servlet而通信框架 则是属于交互部分
Servlet4.0特性
为 HTTP/2 做准备，全包含服务器推送 HTTPS 3.1 中的注解和异步是其中非常抢眼的功能。 添加下面的配置 这是类似web.xml的配置方式 采用java代码中来实现出来的。 这个接口也提供 了对于功能的提升。
@ComponentScan(value="courseware.springmvc.mvc",includeFilters=
@Filter(type=FilterType.ANNOTATION,classes=Controller.class)
,useDefaultFilters=false)
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer
@Override
public void configureViewResolvers(ViewResolverRegistry registry)
//默认所有的页面都从 /WEB-INF/ xxx .jsp
//registry.jsp();
registry.jsp("/WEB-INF/", ".jsp");
//静态资源访问
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)
configurer.enable();
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters)
WebMvcConfigurer.super.configureMessageConverters(converters);
// 解决乱码问题
StringHttpMessageConverter shc = new StringHttpMessageConverter();
List<MediaType> supportedMediaTypes = new ArrayList<MediaType>();
supportedMediaTypes.add(MediaType.TEXT_PLAIN);
supportedMediaTypes.add(MediaType.APPLICATION_JSON);
supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
shc.setSupportedMediaTypes(supportedMediaTypes);
shc.setDefaultCharset(Charset.forName("UTF-8"));
converters.add(shc);
// @ResponseBody 转json
Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder()
.indentOutput(true)
.dateFormat(new SimpleDateFormat("yyyy-MM-dd"))
.modulesToInstall(new ParameterNamesModule());
converters.add(new MappingJackson2HttpMessageConverter(builder.build()));
converters.add(new MappingJackson2XmlHttpMessageConverter(builder.createXmlMapper(true).build()));
//拦截器
@Override
public void addInterceptors(InterceptorRegistry registry)
// 测试的拦截器
registry.addInterceptor(new MyFirstInterceptor()).addPathPatterns("/**");
// JWT 令牌拦截器配置，
registry.addInterceptor(new JwtTokenInterceptor())
// /register 和 /login 不需要拦截
.excludePathPatterns("/register", "/login")
.addPathPatterns("/**");
servlet 4.0 新特性push
@WebServlet(value = "/pushFile")
public class PushServlet extends HttpServlet
/** */
private static final long serialVersionUID = 1L;
/*
* 服务器推送使服务器能预测客户端请求的资源需求。然后，在完成请求处理之前，它可以将这些资源发送到客户端。
*
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
PushBuilder pushBuilder = req.newPushBuilder();
// 在某些情况下，客户端可能会为请求事务拒绝服务器推送。
// 如果客户端没有使用安全连接，服务器推送也不会起作用。
// 因此，务必要在对 `PushBuilder` 实例调用方法之前，针对 `null` 返回值进行测试。
if (pushBuilder != null)
// 一次请求，主动推送更多的资源
pushBuilder.path("100x133.jpg").push();
pushBuilder.path("100x133.jpg").push();
getServletContext()
.getRequestDispatcher("/index.jsp")
.forward(req, resp);
针对springmvc中异步的场景，支持异步处理asyncSupported=true 异步响应。
@WebServlet(value = "/asyncServlet", asyncSupported = true)
public class AsyncServlet extends HttpServlet
/** */
private static final long serialVersionUID = 1L;
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
//1、支持异步处理asyncSupported=true
//2、开启异步模式
System.out.println("主线程开始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
AsyncContext startAsync = req.startAsync();
//3、业务逻辑进行异步处理;开始异步处理
startAsync.start(()->
try
System.out.println("副线程开始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
sayHello();
//获取到异步上下文
AsyncContext asyncContext = req.getAsyncContext();
//4、获取响应
ServletResponse response = asyncContext.getResponse();
response.getWriter().write("hello async...");
System.out.println("副线程结束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
// 结束异步执行
startAsync.complete();
catch (Exception e)
e.printStackTrace();
);
System.out.println("主线程结束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
public void sayHello() throws Exception
System.out.println(Thread.currentThread()+" processing...");
Thread.sleep(3000);
SpringMVC 安全相关
Shiro
认证基于什么来做的？ 用户信息 在服务端的 Session ，用户会话 ， session 坏处就是大量占用服务器资源 并且 横向扩展的上 问题 一旦有部分走不通就会出现问题。JWT
JSON Web Token ，双方之间传递安全信息的简洁的、 URL 安全的表述性声明规范。 需要jwt的原因 1. 鉴权逻辑无需访问数据库，任何情况下都不会击穿缓存打到数据库影响业务； 2. 与数据库解耦，横向扩容性佳， Token 发放、验证都可以脱离数据库 3. 同样是提供 Token ，但 JWT 中可附带允许的权限 / 操作，业务无需实现复杂的权限控制逻辑，只需要 判断Token 中是否有对应权限即可； 4. 数据平台主要的功能就是提供数据访问接口与数据上传接口，没有传统 Web 应用的那种上下文关 系。过重的鉴权逻辑不太符合当前业务特点； 5. 使用多版本私钥，通过更改固定版本签名所用的私钥可以批量废除发出的 Token ；使用 Redis 等缓存后亦可实现对单一Token 的回收 6. 业务只有上传 / 拉取这两个操作，只需要区分当前用户是谁即可。 什么情况下使用 JWT 比较合适 1. 只需要区分用户 2. 没有上下文的环境（有其实也可以，但这样他的优势就没那么大） 3. 不想让鉴权用到的数据库成为可能的瓶颈public class JwtTokenInterceptor implements HandlerInterceptor
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception arg3)
throws Exception
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView model) throws Exception
// 拦截每个请求，验证token是否正常
// 不需要在session中存储用户信息，而是通过计算验证信息
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception
response.setCharacterEncoding("utf-8");
String token = request.getParameter("token");
ResponseData responseData = ResponseData.ok();
//token不存在
if(null != token)
Login login = JWT.unsign(token, Login.class);
String loginId = request.getParameter("loginId");
//解密token后的loginId与用户传来的loginId不一致，一般都是token过期
if(null != loginId && null != login)
if(loginId.equals(login.getId()))
return true;
else
responseData = ResponseData.forbidden();
responseMessage(response, response.getWriter(), responseData);
return false;
else
responseData = ResponseData.forbidden();
responseMessage(response, response.getWriter(), responseData);
return false;
else
responseData = ResponseData.forbidden();
responseMessage(response, response.getWriter(), responseData);
return false;
//请求不通过，返回错误信息给客户端
private void responseMessage(HttpServletResponse response, PrintWriter out, ResponseData responseData)
responseData = ResponseData.forbidden();
response.setContentType("application/json; charset=utf-8");
String json = JSONObject.toJSONString(responseData);
out.print(json);
out.flush();
out.close();
OAuth2.0
OAuth （开放授权）是一个开放标准，允许用户授权第三方移动应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或分享他们数据的所有内容。 应用场景 1. 第三方应用授权登录在APP 或者网页接入一些第三方应用时，经常会需要用户登录另一个合作平台。比如 QQ ，微博，微信的授权登录。 2. 原生 app 授权app登录请求后台接口，为了安全认证，所有请求都带 token 信息。如：登录验证、请求后台数据。 3. 前后端分离单页面应用前后端分离框架，前端请求后台数据，需要进行oauth2 安全认证。比如使用 vue 、 react 后者 h5 开发的app 。
这里介绍的主要就是授权。
授权模式- 授权码模式（authorization code）
- 简化模式（implicit）
- 密码模式（resource owner password credentials）
- 客户端模式（client credentials）
需要手动添加 oauth 的jar包
<!-- 不是starter,手动配置 -->
<dependency>
<groupId>org.springframework.security.oauth</groupId>
<artifactId>spring-security-oauth2</artifactId>
<version>2.3.2.RELEASE</version>
</dependency>针对oauth需要添加配置
/**
* 配置资源服务器和授权服务器
*/
@Configuration
public class OAuth2ServerConfig
private static final String DEMO_RESOURCE_ID = "order";
/**
* 资源服务器。
* 将订单作为保护资源。
*
*/
@Configuration
@EnableResourceServer
protected static class ResourceServerConfiguration extends ResourceServerConfigurerAdapter
@Override
public void configure(ResourceServerSecurityConfigurer resources)
resources.resourceId(DEMO_RESOURCE_ID).stateless(true);
@Override
public void configure(HttpSecurity http) throws Exception
http
.authorizeRequests()
.antMatchers("/order/**").authenticated();//配置order访问控制，必须认证过后才可以访问
/**
* 授权服务器
*
*/
@Configuration
@EnableAuthorizationServer
protected static class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter
@Autowired
AuthenticationManager authenticationManager;
@Autowired
RedisConnectionFactory redisConnectionFactory;
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception
// password 方案一：明文存储，用于测试，不能用于生产
// String finalSecret = "123456";
// password 方案二：用 BCrypt 对密码编码
// String finalSecret = new BCryptPasswordEncoder().encode("123456");
// password 方案三：支持多种编码，通过密码的前缀区分编码方式
String finalSecret = "bcrypt"+new BCryptPasswordEncoder().encode("123456");
//配置两个客户端，一个用于client认证，一个用于password认证
clients.inMemory().
/*
* client模式：没有用户的概念，直接与认证服务器交互，
* 用配置中的客户端信息去申请accessToken，客户端有自己的client_id,
* client_secret对应于用户的username,password，而客户端也拥有自己的authorities，
* 当采取client模式认证时，对应的权限也就是客户端自己的authorities。
*
* 适用场景：仅仅是接口的对接，不考虑用户
* */
withClient("client_1")
.resourceIds(DEMO_RESOURCE_ID)
.authorizedGrantTypes("client_credentials", "refresh_token")
.scopes("select")
.authorities("oauth2")
.secret(finalSecret)
.and().
/*
* password模式：系统必须有一套用户体系，在认证时需要带上自己的用户名和密码，以及客户端的client_id,client_secret。
* 此时，accessToken所包含的权限是用户本身的权限，而不是客户端的权限。
*
* 适用场景：需要考虑用户，并且有一套用户权限体系，可以采用password模式
* */
withClient("client_2")
.resourceIds(DEMO_RESOURCE_ID)
.authorizedGrantTypes("password", "refresh_token")
.scopes("select")
.authorities("oauth2")
.secret(finalSecret);
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints)
// 授权信息放到redis中
endpoints
.tokenStore(new RedisTokenStore(redisConnectionFactory))
.authenticationManager(authenticationManager)
.allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);
@Override
public void configure(AuthorizationServerSecurityConfigurer oauthServer)
//允许表单认证
oauthServer.allowFormAuthenticationForClients();
这里注意需要授权 的匹配。
SpringMVC请求处理流程
处理的第一步建立Map<urls,controller>的关系
ApplicationObjectSupport.setApplicationContext AbstractDetectingUrlHandlerMapping.initApplicationContext(context)
这里面有个比较重要的方法 initapplicationcontext 方法
这里面进去到 handlermapping方法 加载 handler。
根据访问url找到对应controller中处理请求的方法
DispatcherServlet doService 、 doDispatch
做分发处理等，数据解析等操作。
反射调用处理请求的方法 , 返回结果视图 AnnotationMethodHandlerAdapter.handle
在 springmvc中这些源码更多的就是 对 请求的处理，相对ioc aop 等简单很多 少了很多扩展点等。
设计模式软件设计七大原则(开闭原则)(代码片段)
...块/函数,对扩展开放,对修改关闭;抽象与实现:用抽象构建框架,用实现扩展细节;优点:提高软件系统的可复用性及可维护性;开闭原则是面向对象设计中,最基础的设计原则,它指导我们建立稳定灵活的系统;开发新功能时,尽量不修改... 查看详情
springmvc入门(代码片段)
SpringMVC入门SpringMVC概述SpringMVC是Spring提供的一个实现了WebMVC设计模式的轻量级Web框架。它与Struts2框架一样，都属于MVC框架，但其使用和性能等方面比Struts2更加优异。SpringMVC具有以下特点：1、是Spring框架的一部分... 查看详情
自己实现一个简化版的springmvc框架(代码片段)
...的正题，在Web应用程序设计中，MVC模式已经被广泛使用。SpringMVC以DispatcherServlet为核心，负责协调和组织不同组件以完成请求处理并返回响应的工作，实现了MVC模式。想要实现自己的SpringMVC框架，需要从以下几点入手： &... 查看详情
spring,springmvc及springboot区别(代码片段)
...定；而对于大部分开发者而言，平时接触最多的应该就是SpringMVC以及SpringBoot了，本文将分别对Spring，SpringMVC以及SpringBoot做总 查看详情
spring,springmvc及springboot区别(代码片段)
...定；而对于大部分开发者而言，平时接触最多的应该就是SpringMVC以及SpringBoot了，本文将分别对Spring，SpringMVC以及SpringBoot做总 查看详情
优雅设计封装基于okhttp3的网络框架：多线程单例模式优化及volatile构建者模式使用解析(代码片段)
关于多线程下载功能，前四篇博文所讲解内容已经实现，接下来需要对代码进行优化。开发一个新功能并不复杂，难的是考虑到代码的扩展性和解耦性，后续需要进行的bug修复、完善功能等方面。此篇内容主要讲... 查看详情
springspringmvc原理及配置详解(代码片段)
1.SpringMVC概述：SpringMVC是Spring提供的一个强大而灵活的web框架。借助于注解，SpringMVC提供了几乎是POJO的开发模式，使得控制器的开发和测试更加简单。这些控制器一般不直接处理请求，而是将其委托给Spring上下文中的其他bean，... 查看详情
设计模式总览及工厂模式详解(代码片段)
...。2.4.设计模式总览写出优雅的代码更好地重构项目经典框架都在用设计模式解决问题Spring就是一个把设计模式用得淋漓尽致的经典框架，其实从类的命名就能看出来，我来一一列举：设计模式名称举例工厂模式BeanFactory装饰器模... 查看详情
springmvc的常用注解(代码片段)
SpringMVC的常用注解前言SpringMVC框架为开发者提供了功能强大的注解机制，可以帮助我们简化代码的开发，提高开发效率，同时使得程序具备更好的扩展性，这一讲就来详细讲解SpringMVC框架中常用注解的具体使用。&... 查看详情
深入理解qtcreator的插件设计架构(代码片段)
...blog.qizr.tech"+++基于插件的设计好处很多,把扩展功能从框架中剥离出来,降低了框架的复杂度,让框架更容易实现.扩展功能与框架以一种很松的方式耦合,两者在保持接口不变的 查看详情
vue项目实战15home页面布局设计及框架搭建(代码片段)
接上篇《14、退出功能及优化EL按需导入、提交Git》上一篇我们结束了登录模块的开发，本篇我们来正式进行Home主页面的开发，先来进行主页面的设计以及开发前的准备工作。一、主页整体布局我们首先看看需要开发的主... 查看详情
优雅设计封装基于okhttp3的网络框架（完）：原生httpurlconnction请求多线程分发及数据转换(代码片段)
前5篇博文完成了此框架的一大模块-----多线程下载，而这两篇文章实现另一大模块------Http基本框架封装，在上一篇博文中完成了HttpHeader的接口定义和实现、状态码定义及response、request接口封装和实现，定义了许多接... 查看详情
智销功能(代码片段)
sssdj:SpringMVC+Spring+SpringDataJpa->现在比较流行的一种设计（Spring全家桶） 要集成三大框架(Spring+SpringMVC+SpringDataJpa) 什么是JPAJPA:(JavaPersistenceAPI)ORM的规范JPA是规范,Hibernate是它的实现(不唯一,但最好)最底层的操... 查看详情
dubbo架构设计及入门案例(代码片段)
框架介绍1.1.1概述Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的RPC实现服务的输出和输入功能，可以和Spring框架无缝集成。Dubbo是一款高性能、轻量级的开源JavaRPC框架，它提供了三大核心能力... 查看详情
若依框架使用数据权限功能(代码片段)
若依框架使用数据权限功能一、作用说明若依数据权限的实现数据权限过滤注解二、操作步骤1.需要数据权限的表设计字段：2.在需要数据权限的方法上加注解部门数据权限注解部门及用户权限注解3.在mybatis的xml中加过滤标签... 查看详情
第一个springmvc应用(代码片段)
第一个SpringMVC应用MVC的思想是将一个应用分成三个部分，即Model,View,Controller让三个部分以最低的耦合方式进行协同工作,从而提高应用的可扩展性和可维护性SpringMVC是一款优秀的基于MVC思想的应用框架,它是Spring提供的一个实... 查看详情
flask框架简介安装及helloworld程序运行(代码片段)
...#xff0c;是用Python语言基于Werkzeug工具箱编写的轻量级Web开发框架。Flask本身相当于一个内核，其他几乎所有的功能都要用到扩展（邮件扩展Flask-Mail，用户认证Flask-Login），都需要用第三方的扩展来实现。其 WSGI ... 查看详情
springmvc的常用注解(代码片段)
SpringMVC的常用注解前言SpringMVC框架为开发者提供了功能强大的注解机制，可以帮助我们简化代码的开发，提高开发效率，同时使得程序具备更好的扩展性，这一讲就来详细讲解SpringMVC框架中常用注解的具体使用。&... 查看详情