spring

在会后的9个月内吧，别急，等等

1、Springe现在一般是版权转移完后两周内收到proof（大多情况都是一周）。2、proof发回后一周内在线。3、在说明中提到有三种方式修改，You can also insert your corrections in the proof PDF and email the annotated PDF。4、 基本上没有要修改的地方。

用PP或EG或MB支付。全球通用的支付方式。不过你得有信用卡，要是没有可以去taobao网去用现金兑换。

这个是SpringerLink数据库各个期刊的更新速度不一样，你查看的这个期刊这一期目录恰好不能查看，并不是自身电脑问题造成的，不用担心。有些杂志在某一卷中可能只有一期，也会造成这种情况。

CookieSession认证方式。SPRINGER电子期刊数据库使用CookieSession认证方式，这种认证方式可以有效防止他人冒名认证，非常安全。

一般来说是可以的，特别是国内的会，作者有需求，主办方一般都会比较在意，反而国际上的大会检索的很慢，问主办方会更准确。其实由springer出版本身比进EI价值要高吧，个人认为。

如果是嫌字体太小, 可以紧接在 egin{document} 之后加一个 mag=1200 命令. 其效果相当于把文章整体放大了 1.2 倍. 你还可以把 1200 换成别的数, 得到其他的倍率.如果这样处理之后文章的版面偏离页面中心太多, 可以在 egin{document} 之前用 hoffset=10mm, voffset=10mm 来调节. 这里 10 也可以换成其他数字, 还可以是负数.注意这样需要用 latex 编译, 再转成 pdf, 如果直接用 pdflatex 编译, 其结果有时会和原来一样.另外, 这个办法对 amsart 类, 是无效的. 但对 springer 的模板有效(测试过).

一页还要多吗？那就只有跨页了

可以第一作者投稿没有帐号就先到官网去注册一个帐号，然后马上收 email 后开通帐号。接着登入投稿系统投稿；开始提交新的论文初稿；现阶段，这个期刊不收 Letter, Comment, Short communication 等短文。接着继续填写论文题目；输入完论文题入后就是添加作者；接着继续填写摘要；然后输入关键词，关键词要用分号隔开，框框上方有范例可以参考；这阶段是选则论文的类别及属性。选择正确的论文类别，有助于 editor 指派研究领域相同的 reviewer，若找不到相同的类别，可以选择相近的大类。接下来，就是上传所有的文件。

glassman782(站内联系TA)你先按单栏，没有问题的makunjida(站内联系TA)先单栏审稿后双栏xurchen(站内联系TA)刚问了一个同学，他投的通信学报。说是投稿的时候是双栏glassman782(站内联系TA)那就按双栏整，其实很多杂志投稿时单栏，最后校稿是双...

问题答案如下：Springer has arrangements with several funders and institutions, in which the cost of publishing your article as open access with Springer"s Open Choice option is paid directly from the library"s budget.特殊背景If you as the corresponding author are affiliated with one of the institutions in the list below, please confirm the affiliation by choosing it in the drop-down menu.If your affiliation is not listed in the drop down list to the left, please insert it into the field below.*前面说支助，后面说单位，不明白怎么填？没有支助不开放获取的话，是否是在第二栏填写学校就行？前面提示你，与你文章研究经费有关的单位可以有多个，左边1栏是期刊列出的有特殊背景的机构，可以直接选择1个或多个，如果你的不是，请在右边填写1个或多个机构或单位

可以。springer可以在网页处点击引用,引用格式选择为EndNote,然后导出为RIS文件,即可用endnote软件导出参考文献

国外的专著出版原则上是不收费的。但是，受中国特殊市场的影响，有一些机灵的外商也可以收费了。但像springer这样的世界巨头级出版社只要符合他们的出版范围，认为你的学术著作有价值，应该不收费的。但你必须是著名学者才行吧。如果它们收费的话，费用应该不会少。毕竟品牌放在那里啊。管它收费不收费，直接把稿子投过去不就得了吗？编辑自然会给你反馈的。如果你能够在它那里出版，无论多少钱，建议你都出。在学术界，很认可它的品牌的！不过，要小心，现在骗子很多，一定要找到官网去投稿。还有啊，如果你英文足够好，不要投springer中国公司，直接投总部。这样收费的可能性更小。其中道理，你懂的

1.Reject2.Major Revision3.Minor Revision4.Accept首先，最常收到的审稿人意见就是Reject了。大部分同学投出的第一篇或是前几篇期刊文章有很大概率会被拒绝。这时会收到审稿人referee的一些修改意见，以及审稿人认为的你的paper中有哪几点不足的地方。有时审稿人还会给你推荐其他期刊，你可以修改你的paper后再转投其他期刊。收到Major Revision就说明审稿人对你的paper是认可的，认为你的内容确实有contribution。除此之外，审稿人一般会给你若干条意见，可以根据每条意见进行修改。在回复审稿人的邮件中，你还需要针每一条意见回复审稿人。因此收到Major Revision也算是一个好消息了。paper投出去之后直接被accept的概率很小，因此Minor Revision可以算是很不错的消息了。

你好，Computational Mechanics期刊的LaTex模板在附件里。在期刊主页http://www.springer.com/materials/mechanics/journal/466右侧的Instructions for Authors里也可以看到。如有帮助还望采纳回答。

文章被Springer下的杂志接收了，主编给发了邮件，说3-4周后proof会发出，让跟踪一个网址查看，可是这个网址需要邮箱和密码进入，用投稿系统的通讯作者邮箱密码试了，进不去呀，是不是还得等啊，等出版社那边给发邮件，然后会告诉账号和密码，然后再跟踪啊？如果是这种情况，解决方式如下：你可以通过邮箱注册一个，密码自己设置。当完成之后，以后你在Springer出版社发表或接受论文各个阶段（出版社不同杂志），你都能在;这个帐户中看到。当然，你不注册也行。无论你注册与否，关于你这篇论文杂志都会后续联系你。注册好处是，以后你所有论文都可以在里面看到它们的各种状态！

1、在springer里添加宏包斜杠usepackage“wrapfig”。2、添加作者照片及信息，每个作者结束后同样用斜杠vspace“1em”隔开，距离适当调整即可。

不是杂志，是一个外文的全文数据库，包括图书和期刊等，以科技文献为主，近年来增大了对社会科学文献的收录。

?号代表一个字符。*号代表任意个字符，包括0个字符。查找的时候记得勾上单元格查找，不然你找王某的话，王某某的单元格也会被找到，因为该单元格包含王某。

很高兴告诉你！接收后就是proof，即校稿，主要都是下面这些内容这表示你的文章已经录用后，在发给你proofs之前，要先填一些东西，第一个是order open access，这个的意思是如果你订了，你要付给，而你的文章别人可以随便，不用付，意思就是你帮他们付了，所以不要订这个。另一个是order paper offprints ，就是你是不是要订纸质的论文，也要加，建议不要。第三是是否要把图片以彩色出版，这个也要加，所以也建议不要。第四个是转让版权，这个点同意就可以了。然后你会收到一个确认，记住，上面的选项有些是订了就不能修改的。注意不要弄错了。在发给你proofs的时候，会有一个允许出版许可的文件，你可以打印下来 ，签好字，然后扫描一下，和corrections一起发给就行了。为你解除疑惑是我的快乐！

springer版权转让协议可在官网下载。官网可以下载正版授权的springer版权转让协议。著作权转让合同是指著作权人将著作财产权的一部或全部移转给权利受让人，权利受让人应支付相应报酬的协议。著作权转让合同为双务、有偿合同。合同的客体为无形财产权。经转让后，受让人便取得该项无形财产的专有权。

1、PDF和EPUB格式。Springer电子期刊采用PDF和EPUB，具有可移植性、可检索性和易访问性。注意事项：springer平台下的电子图书包括Springer出版集团和Palgrave出版集团出版的电子图书。2、没有APDF格式和BJP格式。

springer是sci几区：springer会议论文属于SCI论文JCR2区，中科院3区（环境类）。springer会议论文由Springer出版社出版，期刊收录：SCI数据库收录，检索稳定，影响因子：3.0+（2019年新）。

Springer Nature公司，是世界上最大的生物医学和生命科学实验指南合集SpringerProtocols:实验室指南数据库主要面向生物化学、分子生物学、以及生物医学等学科，很多期刊在相关学科拥有较高的排名。Springer Protocols由Springer Nature公司出版，是世界上最大的"生物医学和生命科学实验指南合集，Springer Protocols3实验室指南数据库主要面向生物化学、分子生物学、以及生物医学等学科，很多期刊在相关学科拥有较高的排名。首版于1869年11月4日的《自然》是世界上历史悠久的、最有名望的科学杂志之一，许多科学研究领域中，很多最重要、最前沿的研究结果都是以短讯的形式发表在《白然》上。她原隶属于伦敦的麦克米伦科学和教育公司，旗下拥有《自然》、自然子刊和《科学美国人》等众多高水平期肝刊，在国际学术出版行业有非常重要的地位；Springer是德国柏林的科学和商业传媒公司。

springer期刊是sci论文2区。springer是世界上最大的科技出版社之一，收录了2900+本期刊，其中，60%以上被SCI和SSCI收录。收稿主题范围包括天文学、行为科学、生物医学科学、商业与管理、化学、气候、计算机科学、地球科学、经济学、教育与语言、能量、工程、环境科学、食品科学与营养、一般利益、地理、法律、生命科学、材料、数学、医学、哲学、物理学、公共卫生、社会科学、统计数字、水等等。期刊的介绍期刊，定期出版的刊物。如周刊、旬刊、半月刊、月刊、季刊、半年刊、年刊等。由依法设立的期刊出版单位出版刊物。期刊出版单位出版期刊，必须经新闻出版总署批准，持有国内统一连续出版物号，领取《期刊出版许可证》。从广义上来讲，期刊的分类，可以分为非正式期刊和正式期刊两种。非正式期刊是指通过行政部门审核领取“内部报刊准印证”作为行业内部交流的期刊，但也是合法期刊的一种，一般正式期刊都经历过非正式期刊过程。正式期刊是由国家新闻出版署与国家科委在商定的数额内审批，并编入“国内统一刊号”，办刊申请比较严格，要有一定的办刊实力，正式期刊有独立的办刊方针。

SpringerLink系统提供其学术期刊及电子图书的在线服务。springer平台下的电子图书包括Springer出版集团和Palgrave出版集团出版的电子图书。图书馆采购的Springer出版的电子书仅2005版权年至今的可以下载全文，2005年之前回溯数据不能下载全文。Springer是世界上著名的学术出版集团。该数据库是Springer推出全球最大规模的综合性的网上电子图书系列。此系列电子书是根据科研人员需求而特别设的网上电子书数据库，该数据库数据回溯自1997年，目前包括12000种图书供读者阅读，并还在以每年增加3000余种新书的速度增加。Palgrave出版的电子书我们仅采购了2015年之后Behavioral Science and Psychology，Business and Management，Economics and Finance，Education四个学科的数据，可以下载全文，2015版权年之前的Palgrave电子书属于回溯内容，不能下载全文。具体可访问期刊以及电子图书全文可参见附件使用方法。

用maven导入的？导入的包是否有非mave仓库中的？

由于Spring Boot 内嵌了 Tomcat 容器，所以不用把项目打成war包，再放到Tomcat中去运行。但是随之出现了个问题，基于Tomcat的Web应用都有一个 /webapp 目录来存放前端页面和静态资源等文件。那么Spring Boot中应该放在哪里呢？ 如果你是用Spring Initializr新建的项目的话，那么当你打开项目，就会看到： 对， /resources 目录下已经存在了两个包： /static 用来存放静态文件 /templates 用来存放前端页面 Ps：没有目录的话可以自己创建 我们写一个最简单的HTML页面，放在 /templates 下： 可能你注意到了，在 <html lang="zh-CN" xmlns:th="http://www.thymeleaf.org"> 中多了点东西，没关系，继续往下看。 我们写一个Spring MVC中最简单的Controller,用来返回hello.html： 然后通过Postman来测试一下接口： 可以看到报错了，错误提示说，可能是没有指定视图。 我们知道在传统的Tomcat Web应用里面，还需要配置web.xml与SpringMVC。 不过也太麻烦啦，所以Spring Boot就简化了这些配置，并且推荐使用Thymeleaf前端模板引擎。 前面提到的多了点东西也就是这个引擎的语法。 我用Gradle做依赖管理： 可以看到返回的就是hello.html Thymeleaf语法也是个坑，有时间再去看看吧~

Request参数假设请求的url为:/user/get?id=121、访问参数id可以使用param前缀，例如：${param.id!=null}检查是否有参数id；2、参数是一个数组，因为它可以多值比如?id=a&name=test，所以可以采用下标的方式访问，例如：<p th:text="${param.q[0]}" th:unless="${param.q == null}">11</p>3、还有一种访问方式是使用#httpServletRequest对象，可以直接进入javax.servlet.http.HttpServletRequest对象，例如：<p th:text="${#httpServletRequest.getParameter("id")} th:unless="${#httpServletRequest.getParameter("id") == null}">11</p>Session属性比如后台为session添加了一个sessionValue属性，和Request参数访问方式类似，这里使用session前缀：<div th:text="${session.sessionValue}">[...]</div>同样的，还可以使用#httpSession方式访问，它直接进入javax.servlet.http.HttpSession对象。ServletContext属性1、ServletContext属性可以在request和session中共享，未来访问ServletContext属性，可以使用application前缀：比如后台为ServletContext添加了一个myContextAttribute属性，那么我们可以这样访问：<div th:text="${application.myContextAttribute}">[...]</div>2、<div th:text="${application.size()}">33</div> 将返回application的数量；3、输出其所有键值对：<div th:each="attr:${application.keySet()}"><span th:text="${attr}">key</span><span th:text="${application.get(attr)}">value</span></div>Spring beansThymeleaf可以通过@beanName访问Spring应用上下文中注册的bean，如<div th:text="${@urlService.getApplicationUrl()}">...</div>在这个例子中，@urlService就是在上下文中注册的Spring Bean的名字

你好！希望对你有帮助！

模板引擎这个词，咋听起来，有点高大上的意味。 实际上，模板引擎是非常平易近人的技术。譬如大家可能都比较熟悉的 JSP ，就是一种比较典型的模板引擎。 当浏览器将请求抛给控制器，控制器处理好数据后，就跳转 JSP 等模板引擎页面。注意在跳转的同时，还会将数据组装好，也交给模板引擎处理。 模板引擎会根据数据，和模板引擎的规则，动态生成 HTML 页面，最后返回给浏览器显示。 我们使用 Spring Boot 开发 Web 项目，大体上有两种方式。 第一种方式，是后端服务化的方式，也是当前的主流方式。前端是静态的 HTML 页面，通过 Ajax 请求 Spring Boot 的后端接口。 Spring Boot 返回数据一般采用 JSON 格式，前端接收后将数据显示。 第二种方式，是采取模板引擎的方式。前端的请求，到达 Spring Boot 的控制器后，控制器处理请求，然后将返回数据交给模板引擎。模板引擎负责根据数据生成 HTML 页面，最后将 HTML 返回给浏览器。 我个人比较推荐第一种方式，说一下该方式的几个优点： 本篇是讲模板引擎，也得说说模板引擎的优点，王婆卖瓜不能光夸草莓啊。模板引擎开发的页面，对搜索引擎 SEO 比较友好；还有就是简单的页面，如果用模板引擎开发速度比较快，毕竟模板化的方法，目的就是减少重复提高效率。 Spring Boot 支持的模板引擎种类很多，常见的有 FreeMarker 、 Thymeleaf 、 JSP 。 因为这些模板引擎使用的用户都不少，所以我们逐一介绍下其实现过程。 至于孰优孰劣，请各位看官自行评价。正所谓：尺有所短，寸有所长，各取所爱，万物生长！ 本篇我们开发一个商品浏览项目实例。 此处说一个我个人的经验：在做一个项目或一个模块的时候，不要一开始就动手写代码，最好是谋定而后动。 我们作为程序员，实际上是整个程序世界的总指挥。应该先整体规划，再实现局部。这种总分型的开发方法便于我们理顺思路，提高编码效率！ 好的，我们来思考下，实现商品浏览项目实例的整体流程： 整体流程 可以看到，我们是先建立了控制器方法和页面，再去实现其中的具体细节。这样可以让我们的思维保持连贯性和整体性，在做一些页面和方法较多的项目时，会感觉更加顺畅。 我们按整体流程，使用 FreeMarker 模板引擎，来实现商品浏览功能。 使用 Spring Initializr 创建项目，Spring Boot 版本选择 2.2.5 ， Group 为 com.imooc ， Artifact 为 spring-boot-freemarker ，生成项目后导入 Eclipse 开发环境。 引入 Web 项目及 FreeMarker 模板相关的依赖项，代码如下： 实例： 创建控制器类，由于是商品相关的控制器，所以命名为 GoodsController ，代码如下： 实例： 我们具体解释下该类的作用。 我们 resource/templates 目录下新建商品页面 goods.ftl ，先不必实现具体功能，代码如下： 实例： 此时我们启动项目，然后访问 http://127.0.0.1:8080/goods ，即可显示对应页面内容。 定义商品类 GoodsDo 用来描述商品信息，注意 Do 表示数据模型对象（Data Object），代码如下： 实例： 然后我们编写服务类 GoodsService ，提供获取商品列表的方法。注意此处仅仅是演示模板引擎，并不需要访问数据库，直接返回一个指定内容的商品列表。 实例： 此时，我们的控制器就可以注入 GoodsService 类型的组件，然后调用其方法了。 实例： 注意 model.addAttribute("goodsList", goodsService.getGoodsList()); ，我们将商品列表相关的数据交给模板引擎去处理。 此时我们可以根据 FreeMarker 模板引擎，按模板规则显示商品信息了。 实例： 注意我们通过 FreeMarker 的模板语法，输出了商品列表信息。关于 FreeMarker 模板引擎更多的语法规则，感兴趣的同学可以后续查阅更多资料。 启动项目，打开浏览器访问 http://127.0.0.1:8080/goods ，即可查看输出结果。 Thymeleaf 和 FreeMarker ，都是模板引擎，使用方法基本类似。此处我们仅仅是给出一个范例，不再做过多的解释。 使用 Spring Initializr 创建项目， Spring Boot 版本选择 2.2.5 ， Group 为 com.imooc ， Artifact 为 spring-boot-thymeleaf ，生成项目后导入 Eclipse 开发环境。 引入 Web 项目及 Thymeleaf 模板相关的依赖项。 实例： 创建控制器类， GoodsController ， Thymeleaf 直接使用 HTML 作为模板页面，故代码如下： 实例： 我们在 resource/templates 目录下新建商品页面 goods.html ，先不必实现具体功能，代码如下： 实例： 此时我们启动项目，然后访问 http://127.0.0.1:8080/goods ，即可显示对应页面内容。 商品类 GoodsDo ，服务类 GoodsService ，这两个类与上面没有区别直接放出代码。 实例： 实例： 好的，此时我们的控制器就可以注入 GoodsService 类型的组件，然后调用其方法了。 实例： 此时我们可以根据 Thymeleaf 模板引擎，按模板规则显示商品信息了。 实例： 注意我们通过 Thymeleaf 的模板语法，输出了商品列表信息。关于 Thymeleaf 模板引擎更多的语法规则，感兴趣的同学可以后续查阅更多资料。 启动项目，打开浏览器访问 http://127.0.0.1:8080/goods ，即可查看输出结果。 到此，大家基本上也能发现，这两种方式除了模板页面文件内容不同，其他地方基本都是一模一样的。 也就是说，模板引擎主要负责通过一些模板标签，将控制器返回的数据解析为网页。 注意 Spring Boot 官方已经不推荐使用 JSP 了，确实操作起来也比较麻烦。但是由于 JSP 用户体量还是比较大的，所以此处还是简单演示下，开发步骤与 FreeMarker / Thymeleaf 基本一致。 使用 Spring Initializr 创建项目， Spring Boot 版本选择 2.2.5 ， Group 为 com.imooc ， Artifact 为 spring-boot-jsp ，生成项目后导入 Eclipse 开发环境。 引入 Web 项目及 JSP 模板相关的依赖项。 实例： 创建控制器类， GoodsController ，代码如下： 实例： 手工添加 src/main/webapp 及子目录如下，同时目录下放一个 goods.jsp 用于测试。注意该目录是一个 Source Folder 源代码目录，不是普通文件夹目录。 spring-boot-jsp 项目结构 实例： 注意，我们还需要添加一个视图解析器，实现 JSP 页面往指定目录跳转。 实例： 此时我们启动项目，然后访问 http://127.0.0.1:8080/goods ，即可显示对应页面内容。 商品类 GoodsDo ，服务类 GoodsService ，这两个类与上面没有区别直接放出代码。 实例： 实例： 好的，此时我们的控制器就可以注入 GoodsService 类型的组件，然后调用其方法了。 实例： 此时我们可以根据 JSP 模板引擎，按模板规则显示商品信息了。 实例： 注意我们通过 JSP 的模板语法，输出了商品列表信息。关于 JSP 模板引擎更多的语法规则，感兴趣的同学可以后续查阅更多资料。 启动项目，打开浏览器访问 http://127.0.0.1:8080/goods ，即可查看输出结果。 最后大家应该也发现了， FreeMarker 和 Thymeleaf 的用法几乎是一模一样的，而 JSP 还需要手工添加一些目录和配置。 三种方式各有优劣， FreeMarker 模板语法比较简洁， Thymeleaf 可以直接使用 HTML 作为模板文件， JSP 用户群体广泛。 但是三种方式，都是一种模板引擎而已，将控制器返回数据转化为 HTML 页面显示，本质上没啥区别，大家对模板引擎有一个了解即可。

Whitelabel Error PageThis application has no explicit mapping for /error, so you are seeing this as a fallback.Sun Apr 08 10:47:03 CST 2018There was an unexpected error (type=Internal Server Error, status=500).Error resolving template "books_upload", template might not exist or might not be accessible by any of the configured Template Resolvers同问？？？？

thymeleaf是一个前端模板，最近做的项目是通过springboot,angularjs,thymeleaf结合完成的。

看不懂

Thymeleaf只是Spring boot官方默认推荐使用，并且它好多项目示例也是通过Thymeleaf来展示，可以说，用Thymeleaf的话，你可以默认很多配置；但是如果你希望使用其它引擎也是可以的，推荐有(Spring boot 2.0.1):FreeMarkerGroovyThymeleafMustache此外，也可以使用一些其它的模板引擎，只要这些兼容Spring boot都可以使用。附一个模板性能测试(该测试是2年前的，目前Thymeleaf 3已出，性能不好说)。

我认为，虽然他的测试结果非常糟糕，但是官方说明了，3.0版本的重点是性能有非常显著的提升，因此Spring才去推荐使用它。

Thymeleaf是Springboot官方推荐的模板引擎，但仅能渲染html xhtml这类型的格式，是实实在在的页面模板引擎。 开发过程中会遇到各种各样的需求，想要调用springboot上下文中bean的方法，thymeleaf使用@来调用bean方法： 这里我简单解释一下，我在所有业务上的css和js上的资源路径后缀加了一个时间戳的参数，在开发阶段保证了因浏览器缓存，带来的预览不及时等问题，因此我在常量中设置了参数dev，根据dev常量的参数来动态开启后缀。 浏览器开发者模式，效果如下： 常量方法很也普通 如上所示，thymeleaf @{}标签是资源标签，可以保证引用的资源开头都会加上contextPath， thymeaf使用${}来表示变量，使用@跟上bean的名称就可以调用了，是不是很简单。

我们再创建一个消费者8803，现在的启动一个注册中心，一个生产者，两个消费者 我们通过生产者发送两条消息，看看消费者会发生什么 我们可以看到，8802的消费者消费了这两条消息，并且8803的消费者也消费了这两个消息，那这样会出现什么问题呢？ 比如在如下场景中，订单系统我们做集群部署，都会从RabbitMQ中获取订单信息，那如果 一个订单同时被两个服务获取到 ，那么会造成数据错误，我们要避免这种情况。 这时 我们可以使用Stream中的消息分组来解决 注意在Stream中处于同一个group中的多个消费者是竞争关系，就能够保证消息只会被其中一个应用消费一次。 不同组是可以全面消费的（重复消费） 同一组内会发生竞争关系，只有其中一个可以消费 我们知道原理了是由于两个消费者在不同的分组导致的，那么我们只要把两个消费者配置成同一个分组即可 我们只需要在两个消费者的配置文件中配置同一个分组 配置好后我们同样启动四个服务，一个注册中心，一个提供者，两个消费者。 我们先看一下RabbitMQ控制台 可以看到我们配置的分组可以在MQ中显示出来了 接下来我们通过生产者发送四个消息进行测试 然后我们分别观察一下消费者 现在就是通过轮询的方式把消息发送给消费者啦！ 我们先把消费者停掉，只留下注册中心和生产者，然后生产者再发送几条消息。 然后我们把其中一个消费者的group去掉 我们可以看到去掉group的消费者并没有获取到消息，而另一个在启动成功后就自动读取了消息。 这表明group属性既可以防止重复消费，也同样具有持久化的功能。

在vector菜单的point面板中。Grasshopper（简称GH）是一款可视化编程语言，它基于Rhino平台运行，是数据化设计方向的主流软件之一，同时与交互设计也有重叠的区域。与传统设计方法相比，GH的最大的特点有两个：一是可以通过输入指令，使计算机根据拟定的算法自动生成结果，算法结果不限于模型，视频流媒体以及可视化方案。二是通过编写算法程序，机械性的重复操作及大量具有逻辑的演化过程可被计算机的循环运算取代，方案调整也可通过参数的修改直接得到修改结果，这些方式可以有效的提升设计人员的工作效率。新款，读音是xīn kuǎn，汉语词语，指新的款式，新近归顺。出自《答大同巡抚贾春宇书》。明张居正《答大同巡抚贾春宇书》：“今三卫之夷，朝入贡而暮犯抢，朝廷未能一一诘治之也，而欲责之于新款之虏，能乎？”

JacksonAllowNull <pre class="md-fences md-end-block ty-contain-cm modeLoaded" spellcheck="false" lang="java" cid="n60" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; caret-color: rgb(51, 51, 51); color: rgb(51, 51, 51); font-style: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: auto; text-indent: 0px; text-transform: none; widows: auto; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; text-decoration: none; background-position: inherit; background-repeat: inherit;">/** JacksonHttpMessageConverter <pre class="md-fences md-end-block ty-contain-cm modeLoaded" spellcheck="false" lang="java" cid="n65" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-size: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit; caret-color: rgb(51, 51, 51); color: rgb(51, 51, 51); font-style: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: auto; text-indent: 0px; text-transform: none; widows: auto; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; text-decoration: none; background-position: inherit; background-repeat: inherit;">@Component public class JacksonHttpMessageConverter extends MappingJackson2HttpMessageConverter { /** //解决 /instances/%5Bobject%20Object%5D/actuator/metrics // https://github.com/codecentric/spring-boot-admin/issues/1517 objectMapper.addMixIn(InstanceId.class, InstanceIdMixin.class); String[] pwdConstructor = new String[]{".*password$"}; objectMapper.registerModule(new AdminServerModule(pwdConstructor)); //解决domain.values.Registration cannot deserialize from Object SimpleModule simpleModule = new SimpleModule(); simpleModule.addSerializer(Registration.class, ToStringSerializer.instance); simpleModule.addDeserializer(Registration.class, new RegistrationDeserializer()); objectMapper.registerModule(simpleModule); } /** /** private class MyBeanSerializerModifier extends BeanSerializerModifier { @Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { for (Object beanProperty : beanProperties) { BeanPropertyWriter writer = (BeanPropertyWriter) beanProperty; / 过滤允许为null的注解 / if (ObjectUtil.isNull(writer.getAnnotation(JacksonAllowNull.class))) { if (isArrayType(writer)) { writer.assignNullSerializer(new NullArrayJsonSerializer()); } else if (isNumberType(writer)) { writer.assignNullSerializer(new NullNumberJsonSerializer()); } else if (isBooleanType(writer)) { writer.assignNullSerializer(new NullBooleanJsonSerializer()); } else if (isStringType(writer)) { writer.assignNullSerializer(new NullStringJsonSerializer()); } } /* 防止Long精度丢失 */ // if(isLongType(writer)){ // writer.assignSerializer(new ToStringSerializer()); // } } return beanProperties; } private boolean isArrayType(BeanPropertyWriter writer) { Class<?> clazz = writer.getType().getRawClass(); return clazz.isArray() || Collection.class.isAssignableFrom(clazz); } private boolean isStringType(BeanPropertyWriter writer) { Class<?> clazz = writer.getType().getRawClass(); return CharSequence.class.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz); } private boolean isNumberType(BeanPropertyWriter writer) { Class<?> clazz = writer.getType().getRawClass(); return Number.class.isAssignableFrom(clazz); } private boolean isLongType(BeanPropertyWriter writer) { Class<?> clazz = writer.getType().getRawClass(); return Long.class.isAssignableFrom(clazz); } private boolean isBooleanType(BeanPropertyWriter writer) { Class<?> clazz = writer.getType().getRawClass(); return clazz.equals(Boolean.class); } } private class NullArrayJsonSerializer extends JsonSerializer<Object> { @Override public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider provider) throws IOException { if (o == null) { jsonGenerator.writeStartArray(); jsonGenerator.writeEndArray(); } } } private class NullStringJsonSerializer extends JsonSerializer<Object> { @Override public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { jsonGenerator.writeString(StringUtils.EMPTY); } } private class NullNumberJsonSerializer extends JsonSerializer<Object> { @Override public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { jsonGenerator.writeNumber(0); } } private class NullBooleanJsonSerializer extends JsonSerializer<Object> { @Override public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { jsonGenerator.writeBoolean(false); } } }</pre> https://gitee.com/miaoyinjun/jjche-boot

这篇先说明用法，下篇分析以下场景是如何将 Bean 注册进 IOC容器的。 这种用法在项目中是非常常见的，基本上是必有。我们来看下用法： 这样一个 Bean 就注册进 IOC 容器了，Bean 的名称默认是方法名，并且是不会转换大小写的，也就是假如你的方法名是 TestBean() ,那么 Bean 的名称就是 TestBean 。当然我们也可以使用 name 或者 value 指定 Bean 的名称，比如 @Bean(value = "testBean")，如果二者同时存在则会报错。 我们来看下其他属性： autowireCandidate：默认值是 true 。如果设置为 false 的话，那么通过 byType 的方式获取 Bean 就会报错，当然我们可以使用 Resource 注解获取。 initMethod：在 Bean 实例化后调用的初始化方法，值是 Bean 类中的方法名。 destroyMethod：在 Bean 要销毁时调用的清理方法，值是 Bean 类中的方法名。 @Bean 注解只能定义在 @Configuration 类下吗？ NO NO NO，它可以定义在任意能被 IOC 扫描的注解下，比如 @Component注解，至于区别，下篇再讲。 先讲普通用法： 深度用法： ComponentScan 注解中有两个这样的属性：includeFilters 与 excludeFilters，前一个是只包含规则，后一个是排除包含规则，他们的值是一个 @Filter 注解的形式，Filter 中的 type 有 5 中类型，分别如下。 1、ANNOTATION 第一种是以注解的形式包含或不包含，比如： 这里边要配置useDefaultFilters = false 禁用默认规则，因为默认规则是扫描所有，配只包含就没用了。这里的意思只扫描 Configuration 注解。 2、ASSIGNABLE_TYPE 这种是包含我们给定的类型，不管是给定的类型和子类都会被包含进 IOC 容器。 然后我们发现 testBean 注册进去了，为什么我们不标注 @Component 这样的注解实例也会被注册进 IOC 呢？因为 ComponentScan 会扫描包下所有文件，只要符合我们定义的过滤规则，它就会将 Bean 注册进 IOC 容器中。 3、ASPECTJ ASPECTJ 是使用 aspectj 表达式 4、REGEX REGEX 是使用正则表达式 5、CUSTOM 这种呢就是我们 SpringBootApplication 注解用到的方式了，我来解释一下具体规则：这种方式是可以自己自定义扫描规则，它接受一个实现 TypeFilter 接口的类。 当它扫描类的时候扫描到了 TestBean，然后符合了我的匹配规则（也就是返回true）就注册进去了。 下面的例子中，我们直接看 Spring 源码的实现比较具有代表性一点。 我们点进 @EnableTransactionManagement 注解中，发现了这个 @Import(TransactionManagementConfigurationSelector.class)，它的作用就是将类导入，类会被注册进 IOC 容器中。 这个注解放置的位置要是 Spring 能扫描到的地方，不然 Spring 也不会主动去解析这个注解。 如果我们自己要使用注解的话，我们可以做个类似于 EnableTransactionManagement 的功能插拔式导入配置类，这样就可以实现动态开启一些 Bean 了。 我们还是来看下 TransactionManagementConfigurationSelector 这个类，看下它的继承关系发现它间接性的实现了 ImportSelector 接口，主要看它实现的这个方法： 这个方法的作用就是根据你返回的类全限定名（org.springframework.context.annotation.AutoProxyRegistrar）数组来创建 Bean 。 实现了 ImportSelector 的类也是需要使用 @Import 导入。 这个我们来看下 @MapperScan （org.mybatis.spring.annotation）导入的 MapperScannerRegistrar 发现它实现了 ImportBeanDefinitionRegistrar： 它的作用是拿到 BeanDefinitionRegistry Bean 的定义信息，然后往里面加 BeanDefinition 就会将相应的对象注册进去，它更深入的就不说了，实际上就是解析下注解属性，然后扫描相应的包下的类注册 Bean。我们自己搞个简单的。 这样就注册了一个 Bean 名称是 testBean 类型是 TestBean 类型的 Bean 了。 如果注册的是一个有参构造器呢？那就这样： addConstructorArgValue 根据构造器参数的顺序去添加。 实现了 ImportBeanDefinitionRegistrar 的类也是需要使用 @Import 导入。 然后 TestBean 就注册进去了，打印的时候我们发现 Bean 的名称是 MyFactoryBean 的全限定名，但是它的类型是 TestBean 类型的，如果想要获取 MyFactoryBean 类型的 Bean 的话，通过 Bean 名称为 &myFactoryBean 就能获取到。 在我们的Spring Boot项目中，一般都是只扫描主类下的所有类，然后将一些被特定注解标注的类加载到IOC容器，但是如果我们将包分离，我们又如何更加方便的将其他包的类加载进来呢？ spring boot提供了一种类似于Java的SPI（服务发现）机制spring.factories，只要在resources目录下创建META-INF文件夹，再创建 spring.factories文件，然后再里面配置 这样在导入当前包的就会自动扫描spring.factories文件，解析后将里面的一些类加载到IOC容器中。具体的实现代码在spring-core的SpringFactoriesLoader类中。 这些就不讲了。

排比把结构相同或相似、语气一致，意思相关联的句子或成分排列在一起。作用：增强语言气氛，加强表达效果。如：他们的品质是那样的纯洁和高尚，他们的意志是那样的坚韧和刚强，他们的气质是那样的淳朴和谦逊，他们的胸怀是那样的美丽和宽广。

接收后就是proof，即校稿，主要都是下面这些内容这表示你的文章已经录用后，在发给你proofs之前，要先填一些东西，第一个是order open access，这个的意思是如果你订了，你要付钱给出版社，而你的文章别人可以随便下载，不用付费，意思就是你帮他们付费了，所以不要订这个。另一个是order paper offprints ，就是你是不是要订纸质的论文，也要加钱，建议不要。第三是是否要把图片以彩色出版，这个也要加钱，所以也建议不要。第四个是转让版权，这个点同意就可以了。然后你会收到一个确认邮件，记住，上面的选项有些是订了就不能修改的。注意不要弄错了。在发给你proofs的时候，会有一个允许出版许可的文件，你可以打印下来 ，签好字，然后扫描一下，和corrections一起发给出版社就行了。

这是一个可数名词a hot (mineral) spring

warm spring

Born down in a dead mans town 生在死人城 The first kick I took was when I hit the ground 我踢出的第一脚就是在我呱呱坠地的一刻 You end up like a dog thats been beat too much 你最终变成了一只被痛扁了的狗 Till you spend half your life just covering up 然后你花了半被子才康复。。。 Born in the u.s.a., I was born in the u.s.a. 生在美国，我生在美国。 I was born in the u.s.a., born in the u.s.a. 我生在美国，生在美国。 Got in a little hometown jam 被卷入了家乡的一场混乱中 So they put a rifle in my hand 他们塞给我一只步枪 Sent me off to a foreign land 把我送到了异国他乡 To go and kill the yellow man 去杀死那些黄种人！ Born in the u.s..a.... （我）生在美国。。。 Come back home to the refinery 回到祖国就去了一家精炼厂工作 Hiring man said son if it was up to me 人事部经理说，小子，如果我曾拥有选择的权利。。。 Went down to see my v.a. man 我一定会去找我的v.a. man ，（v.a.man这个是什么人我实在不知道啦，和越战相关，也许v指得是vietnam越南？） He said son, dont you understand 他还说，小子，你不懂。 I had a brother at khe sahn 我有个兄弟在溪山 Fighting off the viet cong 和越南姥打仗 Theyre still there, hes all gone 他们还在那里，已然逝去。 He had a woman he loved in saigon 他爱上了一位西贡（越南前首都）的姑娘 I got a picture of him in her arms now 我还有他俩相拥（她搂着他）的相片 Down in the shadow of the penitentiary 吞没在监狱阴暗的影子中 Out by the gas fires of the refinery 淹没在精炼厂的火焰后 Im ten years burning down the road 我在我的路上燃烧了10年 Nowhere to run aint got nowhere to go 没出去也不知道前途在何方 Born in the u.s.a., I was born in the u.s.a. 生在美国，生在美国 Born in the u.s.a., Im a long gone daddy in the u.s.a. 生在美国，我是一个离开了很久的父亲。。（这句话我实在没法给你意译，意思太隐晦了） Born in the u.s.a., born in the u.s.a. 生在美国，生在美国 Born in the u.s.a., Im a cool rocking daddy in the u.s.a. 生在美国，我是一个新潮辣爸=。=（引用辣妈的英文说法，就是这个意思，我也找不到更好的词来翻译） 话说，我记得我前两天刚刚翻过这个人的歌 = = 不过这首歌实在是比较难理解。 可能是描述一位参加越战的军人本人对和平、爱情的渴望吧= = 而且，这歌貌似是作者写给他在越战中死去的朋友及所有在越战中死去的烈士的挽歌。楼主大概看看意思吧。

没办法，只能修改你本机的jdk版本。另一个机器上可以装多个jdk版本，不冲突

该类实现了UserDetails接口 内含登录成功或失败后的处理方法 用一个简单的类来接受前端出来的登录信息 实现UserDetailsService接口，重写loadUserByUsername方法，按自己的实际需求来编写验证规则 该类为token校验器，并封装了用户权限，保存至security上下文中 首先SysUserController中有三个测试接口，第一个接口认证后即可访问，第二个接口需要登录的用户拥有ROLE_ADMIN角色，第三个接口需要用户拥有ROLE_USER角色。 返回了token信息 请求头中带上token，因为security配置类中关闭了session，后续请求必须带上token才能访问。 访问成功。 该接口需要ROLE_ADMIN，我们已登录的用户只拥有ROLE_USER，所以该接口不能访问。 结果符合预期 该接口需要ROLE_USER，已登录用户可以访问 结果符合预期 项目源码地址： https://github.com/lan-de/SpringSecurity-01

本文适合： 对Spring Security有一点了解或者跑过简单demo但是对整体运行流程不明白的同学，对SpringSecurity有兴趣的也可以当作你们的入门教程，示例代码中也有很多注释。 大家在做系统的时候，一般做的第一个模块就是 认证与授权 模块，因为这是一个系统的入口，也是一个系统最重要最基础的一环，在认证与授权服务设计搭建好了之后，剩下的模块才得以安全访问。 市面上一般做认证授权的框架就是shiro和Spring Security，也有大部分公司选择自己研制。出于之前看过很多Spring Security的入门教程，但都觉得讲的不是太好，所以我这两天在自己鼓捣Spring Security的时候萌生了分享一下的想法，希望可以帮助到有兴趣的人。 Spring Security框架我们主要用它就是解决一个认证授权功能，所以我的文章主要会分为两部分： 我会为大家用一个Spring Security + JWT + 缓存的一个demo来展现我要讲的东西，毕竟脑子的东西要体现在具体事物上才可以更直观的让大家去了解去认识。 学习一件新事物的时候，我推荐使用自顶向下的学习方法，这样可以更好的认识新事物，而不是盲人摸象。 注 ：只涉及到用户认证授权不涉及oauth2之类的第三方授权。 想上手 Spring Security 一定要先了解它的工作流程，因为它不像工具包一样，拿来即用，必须要对它有一定的了解，再根据它的用法进行自定义操作。 我们可以先来看看它的工作流程： 在Spring Security的官方文档上有这么一句话： Spring Security 的web基础是Filters。 这句话展示了Spring Security的设计思想： 即通过一层层的Filters来对web请求做处理。 放到真实的Spring Security中，用文字表述的话可以这样说: 一个web请求会经过一条过滤器链，在经过过滤器链的过程中会完成认证与授权，如果中间发现这条请求未认证或者未授权，会根据被保护API的权限去抛出异常，然后由异常处理器去处理这些异常。 用图片表述的话可以这样画，这是我在百度找到的一张图片： 如上图，一个请求想要访问到API就会以从左到右的形式经过蓝线框框里面的过滤器，其中绿色部分是我们本篇主要讲的负责认证的过滤器，蓝色部分负责异常处理，橙色部分则是负责授权。 图中的这两个绿色过滤器我们今天不会去说，因为这是Spring Security对form表单认证和Basic认证内置的两个Filter，而我们的demo是JWT认证方式所以用不上。 如果你用过Spring Security就应该知道配置中有两个叫formLogin和httpBasic的配置项，在配置中打开了它俩就对应着打开了上面的过滤器。 换言之，你配置了这两种认证方式，过滤器链中才会加入它们，否则它们是不会被加到过滤器链中去的。 因为Spring Security自带的过滤器中是没有针对JWT这种认证方式的，所以我们的demo中会 写一个JWT的认证过滤器，然后放在绿色的位置进行认证工作。 知道了Spring Security的大致工作流程之后，我们还需要知道一些非常重要的概念也可以说是组件： 上下文对象，认证后的数据就放在这里面，接口定义如下： 这个接口里面只有两个方法，其主要作用就是get or set Authentication。 可以说是SecurityContext的工具类，用于get or set or clear SecurityContext，默认会把数据都存储到当前线程中。 这几个方法效果如下： Authentication只是定义了一种在SpringSecurity进行认证过的数据的数据形式应该是怎么样的，要有权限，要有密码，要有身份信息，要有额外信息。 AuthenticationManager定义了一个认证方法，它将一个未认证的Authentication传入，返回一个已认证的Authentication，默认使用的实现类为：ProviderManager。 接下来大家可以构思一下如何将这四个部分，串联起来，构成Spring Security进行认证的流程： 1. 先是一个请求带着身份信息进来 2. 经过AuthenticationManager的认证， 3. 再通过SecurityContextHolder获取SecurityContext， 4. 最后将认证后的信息放入到SecurityContext。 真正开始讲诉我们的认证代码之前，我们首先需要导入必要的依赖，数据库相关的依赖可以自行选择什么JDBC框架，我这里用的是国人二次开发的myabtis-plus。 接着，我们需要定义几个必须的组件。 由于我用的Spring-Boot是2.X所以必须要我们自己定义一个加密器： 这个Bean是不必可少的，Spring Security在认证操作时会使用我们定义的这个加密器，如果没有则会出现异常。 实现UserDetailsService的抽象方法并返回一个 UserDetails 对象，认证过程中SpringSecurity会调用这个方法访问数据库进行对用户的搜索，逻辑什么都可以自定义，无论是从数据库中还是从缓存中，但是我们需要将我们查询出来的用户信息和权限信息组装成一个 UserDetails 返回。 UserDetails 也是一个定义了数据形式的接口，用于保存我们从数据库中查出来的数据，其功能主要是验证账号状态和获取权限，具体实现可以查阅我仓库的代码。 由于我们是JWT的认证模式，所以我们也需要一个帮我们操作Token的工具类，一般来说它具有以下三个方法就够了： 在下文我的代码里面，JwtProvider充当了Token工具类的角色，具体实现可以查阅我仓库的代码。 有了前面的讲解之后，大家应该都知道用SpringSecurity做JWT认证需要我们自己写一个过滤器来做JWT的校验，然后将这个过滤器放到绿色部分。 在我们编写这个过滤器之前，我们还需要进行一个认证操作，因为我们要先访问认证接口拿到token，才能把token放到请求头上，进行接下来请求。 如果你不太明白，不要紧，先接着往下看我会在这节结束再次梳理一下。 访问一个系统，一般最先访问的是认证方法，这里我写了最简略的认证需要的几个步骤，因为实际系统中我们还要写登录记录啊，前台密码解密啊这些操作。 这里一共五个步骤，大概只有前四步是比较陌生的： 这样的话就算完成了，感觉上很简单，因为主要认证操作都会由authenticationManager.authenticate()帮我们完成。 接下来我们可以看看源码，从中窥得Spring Security是如何帮我们做这个认证的（省略了一部分）： 看了源码之后你会发现和我们平常写的一样，其主要逻辑也是查数据库然后对比密码。 登录之后效果如下： 我们返回token之后，下次请求其他API的时候就要在请求头中带上这个token，都按照JWT的标准来做就可以。 有了token之后，我们要把过滤器放在过滤器链中，用于解析token，因为我们没有session，所以我们每次去辨别这是哪个用户的请求的时候，都是根据请求中的token来解析出来当前是哪个用户。 所以我们需要一个过滤器去拦截所有请求，前文我们也说过，这个过滤器我们会放在绿色部分用来替代UsernamePasswordAuthenticationFilter，所以我们新建一个JwtAuthenticationTokenFilter，然后将它注册为Bean，并在编写配置文件的时候需要加上这个： addFilterBefore的语义是添加一个Filter到XXXFilter之前，放在这里就是把JwtAuthenticationTokenFilter放在UsernamePasswordAuthenticationFilter之前，因为filter的执行也是有顺序的，我们必须要把我们的filter放在过滤器链中绿色的部分才会起到自动认证的效果。 接下来我们可以看看JwtAuthenticationTokenFilter的具体实现了： 代码里步骤虽然说的很详细了，但是可能因为代码过长不利于阅读，我还是简单说说，也可以直接去仓库查看源码： 这样的话，每一个带有正确token的请求进来之后，都会找到它的账号信息，并放在上下文对象中，我们可以使用SecurityContextHolder很方便的拿到上下文对象中的Authentication对象。 完成之后，启动我们的demo，可以看到过滤器链中有以下过滤器，其中我们自定义的是第5个： 就酱，我们登录完了之后获取到的账号信息与角色信息我们都会放到缓存中，当带着token的请求来到时，我们就把它从缓存中拿出来，再次放到上下文对象中去。 结合认证方法，我们的逻辑链就变成了： 登录拿到token请求带上tokenJWT过滤器拦截校验token将从缓存中查出来的对象放到上下文中 这样之后，我们认证的逻辑就算完成了。 认证和JWT过滤器完成后，这个JWT的项目其实就可以跑起来了，可以实现我们想要的效果，如果想让程序更健壮，我们还需要再加一些辅助功能，让代码更友好。 当用户未登录或者token解析失败时会触发这个处理器，返回一个非法访问的结果。 当用户本身权限不满足所访问API需要的权限时，触发这个处理器，返回一个权限不足的结果。 用户退出一般就是清除掉上下文对象和缓存就行了，你也可以做一下附加操作，这两步是必须的。 JWT的项目token刷新也是必不可少的，这里刷新token的主要方法放在了token工具类里面，刷新完了把缓存重载一遍就行了，因为缓存是有有效期的，重新put可以重置失效时间。 这篇文我从上周日就开始构思了，为了能讲的老妪能解，修修改改了几遍才发出来。 作者：和耳朵 链接：https://juejin.cn/post/6846687598442708999

1、JWT的构成 - 头部(header):描述该JWT的最基本的信息，如类型以及签名所用的算法。 - 负载(payload):存放有效信息的地方。 - 签证(signature):base64加密后的header、base64加密后的payload和密钥secret加密后组成。 2、整合JWT 2.1 引入JWT依赖 com.auth0 java-jwt 3.18.3 2.2 编写JWTUtils工具类 package com.stock.utils; import com.auth0.jwt.JWT; import com.auth0.jwt.JWTCreator; import com.auth0.jwt.JWTVerifier; import com.auth0.jwt.algorithms.Algorithm; import com.auth0.jwt.interfaces.DecodedJWT; import com.auth0.jwt.interfaces.Verification; import java.util.Calendar; import java.util.Map; public class JWTUtils { private static final String SING="@#$%^&*"; // 生成token public static String getToken(Map map){ Calendar instance = Calendar.getInstance(); instance.add(Calendar.MINUTE,30); //创建jwt builder JWTCreator.Builder builder = JWT.create(); //payload builder.withExpiresAt(instance.getTime()); map.forEach((k,v)->{ builder.withClaim(k,v); }); //设置签名 String token = builder.sign(Algorithm.HMAC256(SING)); return token; } //验证令牌 public static void verifyToken(String token){ JWTVerifier require = JWT.require(Algorithm.HMAC256(SING)).build(); require.verify(token); } //获取token信息 public static DecodedJWT getTokenInfo(String token){ DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(token); return verify; } } 2.3 编写拦截器 public class JWTInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) { System.out.println("OPTIONS请求，放行"); return true; } HashMap map = new HashMap>(); String token = request.getHeader("token"); try { JWTUtils.verifyToken(token); return true; }catch (SignatureVerificationException e){ map.put("msg","无效签名!"); }catch (TokenExpiredException e){ map.put("msg","token过期!"); }catch (AlgorithmMismatchException e){ map.put("msg","token加密算法不一致"); }catch (Exception e){ map.put("msg","无效签名!"); } map.put("state",404); map.put("path","/login"); //将map转化为字符串返回给前端 String result = new ObjectMapper().writeValueAsString(map); response.setContentType("application/json;charset=UTF-8"); response.getWriter().println(result); return false; } } 注意： 1、token存放在请求的header中； 2、在前后端分离的项目中，发送的GET/POST请求实则为两次请求。第一次请求为OPTIONS请求，第二次请求才是GET/POST请求；在OPTIONS请求中，不会携带请求头的参数，会导致在拦截器上获取请求头为空，自定义的拦截器拦截成功。第一次请求不能通过，就不能获取第二次的请求。所以需要在拦截器中加上如下代码来判断是否为OPTIONS请求，对于OPTIONS请求直接放过。 if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) { System.out.println("OPTIONS请求，放行"); return true; } 2.4 配置拦截器 package com.stock.config; import com.stock.Interceptors.JWTInterceptor; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class IntercepterConfg implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new JWTInterceptor()) .addPathPatterns("/**") .excludePathPatterns("/login"); } } 2.5 编写Controller package com.stock.controller; import com.stock.entity.User; import com.stock.result.Result; import com.stock.service.UserService; import com.stock.utils.JWTUtils; import com.stock.utils.ResultUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; @RestController public class LoginController { private UserService userService; @Autowired public LoginController(UserService userService) { this.userService = userService; } @PostMapping("/login") public Result register(User user){ HashMap map = new HashMap>(); map.put("username",user.getUserName()); String token = JWTUtils.getToken(map); HashMap data = new HashMap>(); data.put("token",token); return ResultUtils.getresult(200,"登录成功!",data); } @GetMapping("/main") public Result tomain(){ return ResultUtils.getresult(200,"访问成功",null); } } 2.6使用Postman测试 - 未登录前访问127.0.0.1:8888/main - 先登录再访问127.0.0.1:8888/main

启动项目时，SpringBoot自动检索所有带@Configuration的注解，所以就将我们的WebSecurityConfig给加载了，这个config中，我们需要在configure(AuthenticationManagerBuilder auth)方法中注册一个继承自UserDetailsService的接口，这个接口中只有一个方法，那就是使用username获取到数据库中用户信息并返回成UserDetail实体。这个方法需要我们按照我们的不同业务场景重写 WebSecurityConfig MyUserDetailsService 其实如果去掉上面的将自定义的JWT过滤器加入到过滤链中的话，这个认证过程已经完成了。使用下面的代码就可以调用起整个认证程序。 核心代码 这一行就会将username和password放到认证程序中进行认证。 也就是需要我们自己的逻辑让他去触发这个代码的实现。就可以自动完成认证程序了。就会触发使用username获取到数据库用户信息，然后经过密码加密比对之后会将认证结果返回。 我们整合JWT其实也很简单，其实就是将JWT的登录部分的操作，使用过滤器封装，将该过滤器放到整个认证的过滤链中 SpringSecurity过滤器的配置无非以下几个条件 先解决逻辑上以上三个问题的答案 针对以上解答，下面用代码来做展示（ps:序号依次对应上面） 完成了以上的配置，前台就可以使用/login/user来进行登录操作了。登录成功会返回一个JSON对象来供前端判断成功与否 全部代码奉上，随意写的注释有点多，不看的可以给删掉

通过 JWT 配合 Spring Security OAuth2 使用的方式，可以避免 每次请求 都 远程调度 认证授权服务。 资源服务器 只需要从 授权服务器 验证一次，返回 JWT。返回的 JWT 包含了 用户 的所有信息，包括 权限信息 。 1. 什么是JWT JSON Web Token（JWT）是一种开放的标准（RFC 7519），JWT 定义了一种 紧凑 且 自包含 的标准，旨在将各个主体的信息包装为 JSON 对象。 主体信息 是通过 数字签名 进行 加密 和 验证 的。经常使用 HMAC 算法或 RSA（ 公钥 / 私钥 的 非对称性加密 ）算法对 JWT 进行签名， 安全性很高 。 2. JWT的结构 JWT 的结构由三部分组成：Header（头）、Payload（有效负荷）和 Signature（签名）。因此 JWT 通常的格式是 xxxxx.yyyyy.zzzzz。 2.1. Header Header 通常是由 两部分 组成：令牌的 类型 （即 JWT）和使用的 算法类型 ，如 HMAC、SHA256 和 RSA。例如: 将 Header 用 Base64 编码作为 JWT 的 第一部分 ，不建议在 JWT 的 Header 中放置 敏感信息 。 2.2. Payload 下面是 Payload 部分的一个示例： 将 Payload 用 Base64 编码作为 JWT 的 第二部分 ，不建议在 JWT 的 Payload 中放置 敏感信息 。 2.3. Signature 要创建签名部分，需要利用 秘钥 对 Base64 编码后的 Header 和 Payload 进行 加密 ，加密算法的公式如下： 签名 可以用于验证 消息 在 传递过程 中有没有被更改。对于使用 私钥签名 的 token，它还可以验证 JWT 的 发送方 是否为它所称的 发送方 。 3. JWT的工作方式 客户端 获取 JWT 后，对于以后的 每次请求 ，都不需要再通过 授权服务 来判断该请求的 用户 以及该 用户的权限 。在微服务系统中，可以利用 JWT 实现 单点登录 。认证流程图如下： 4. 案例工程结构 工程原理示意图如下: 5. 构建auth-service授权服务 UserServiceDetail.java UserRepository.java 实体类 User 和上一篇文章的内容一样，需要实现 UserDetails 接口，实体类 Role 需要实现 GrantedAuthority 接口。 User.java Role.java jks 文件的生成需要使用 Java keytool 工具，保证 Java 环境变量没问题，输入命令如下： 其中，-alias 选项为 别名 ，-keyalg 为 加密算法 ，-keypass 和 -storepass 为 密码选项 ，-keystore 为 jks 的 文件名称 ，-validity 为配置 jks 文件 过期时间 （单位：天）。 生成的 jks 文件作为 私钥 ，只允许 授权服务 所持有，用作 加密生成 JWT。把生成的 jks 文件放到 auth-service 模块的 src/main/resource 目录下即可。 对于 user-service 这样的 资源服务 ，需要使用 jks 的 公钥 对 JWT 进行 解密 。获取 jks 文件的 公钥 的命令如下： 这个命令要求安装 openSSL 下载地址，然后手动把安装的 openssl.exe 所在目录配置到 环境变量 。 输入密码 fzp123 后，显示的信息很多，只需要提取 PUBLIC KEY，即如下所示： 新建一个 public.cert 文件，将上面的 公钥信息 复制到 public.cert 文件中并保存。并将文件放到 user-service 等 资源服务 的 src/main/resources 目录下。至此 auth-service 搭建完毕。 maven 在项目编译时，可能会将 jks 文件 编译 ，导致 jks 文件 乱码 ，最后不可用。需要在 pom.xml 文件中添加以下内容： 6. 构建user-service资源服务 注入 JwtTokenStore 类型的 Bean，同时初始化 JWT 转换器 JwtAccessTokenConverter，设置用于解密 JWT 的 公钥 。 配置 资源服务 的认证管理，除了 注册 和 登录 的接口之外，其他的接口都需要 认证 。 新建一个配置类 GlobalMethodSecurityConfig，通过 @EnableGlobalMethodSecurity 注解开启 方法级别 的 安全验证 。 拷贝 auth-service 模块的 User、Role 和 UserRepository 三个类到本模块。在 Service 层的 UserService 编写一个 插入用户 的方法，代码如下： 配置用于用户密码 加密 的工具类 BPwdEncoderUtil： 实现一个 用户注册 的 API 接口 /user/register，代码如下： 在 Service 层的 UserServiceDetail 中添加一个 login() 方法，代码如下： AuthServiceClient 作为 Feign Client，通过向 auth-service 服务接口 /oauth/token 远程调用获取 JWT。在请求 /oauth/token 的 API 接口中，需要在 请求头 传入 Authorization 信息， 认证类型 ( grant_type )、用户名 ( username ) 和 密码 ( password )，代码如下： 其中，AuthServiceHystrix 为 AuthServiceClient 的 熔断器 ，代码如下： JWT 包含了 access_token、token_type 和 refresh_token 等信息，代码如下： UserLoginDTO 包含了一个 User 和一个 JWT 成员属性，用于返回数据的实体： 登录异常类 UserLoginException 全局异常处理 切面类 ExceptionHandle 在 Web 层的 UserController 类中新增一个登录的 API 接口 /user/login 如下： 依次启动 eureka-service，auth-service 和 user-service 三个服务。 7. 使用Postman测试 因为没有权限，访问被拒绝。在数据库手动添加 ROLE_ADMIN 权限，并与该用户关联。重新登录并获取 JWT，再次请求 /user/foo 接口。 在本案例中，用户通过 登录接口 来获取 授权服务 加密后的 JWT。用户成功获取 JWT 后，在以后每次访问 资源服务 的请求中，都需要携带上 JWT。 资源服务 通过 公钥解密 JWT， 解密成功 后可以获取 用户信息 和 权限信息 ，从而判断该 JWT 所对应的 用户 是谁，具有什么 权限 。 获取一次 Token，多次使用， 资源服务 不再每次访问 授权服务 该 Token 所对应的 用户信息 和用户的 权限信息 。 一旦 用户信息 或者 权限信息 发生了改变，Token 中存储的相关信息并 没有改变 ，需要 重新登录 获取新的 Token。就算重新获取了 Token，如果原来的 Token 没有过期，仍然是可以使用的。一种改进方式是在登录成功后，将获取的 Token 缓存 在 网关上 。如果用户的 权限更改 ，将 网关 上缓存的 Token 删除 。当请求经过 网关 ，判断请求的 Token 在 缓存 中是否存在，如果缓存中不存在该 Token，则提示用户 重新登录 。

在上一节 SpringCloud组件之Ribbon 中，实现了一个Ribbon的Helloword,使用的是Spring Eureka 和Spring Ribbon结合使用，并且使用Ribbon的默认轮询注册清单的负载均衡策略。 Ribbon参数配置通常有两种方式：全局配置和知道客户端配置 通用格式：ribbon.<key>=<value> key：表示参数名称 value：表示参数值 例如：全局配置Ribbon创建连接的超时时间 针对指定的服务进行配置 通用格式 <client>.ribbon.<key>=<value> key：表示参数名称 value：表示参数值 client：表示客户端服务的名称 例如：我们调用的Rest请求时是 http://hello-service/hello/hello ，现在我们来为服务hello-service服务指定他的实例清单（和注册中心中的服务清单一样） 下面将单独使用Spring Ribbon组件来介绍几种Ribbon负载均衡策略，单独使用Ribbon组件，不结合Eureka组件的不同之处在于，不能根据服务名称自动从Eureka的注册中心获取一个服务的实例清单，必须手动在配置文件中添加服务实例清单。 RandomRule策略：该策略实现了从服务实例清单中 随机选择 一个服务实例，作为请求服务对象。 首先创建一个SpringBoot的服务。 pom.xml application.yaml LoadBalanceController类 LoadBalanceMain类 启动main，在浏览器中输入 http://localhost:8015/loadbalance/hello ，多次请求，可以看到页面呈现不同的请求路径。而且这些请求都是随机出现，查看后台打印 RoundRobinRule：该策略实现了按照 线性轮询 的方式一次轮询服务清单上的每个服务实例。 结合上面的例子，修改两个部分，一个是application.yaml中 NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule 一个是LoadBalanceMain 中 修改ribbonRule()的返回值 RetryRule：该策略具备重试机制的实例选择功能，在给定时间内能够得到选择到具体的服务实例就返回，当超过时间还有没选到就返回null，参数maxRetryMillis控制这个超时时间。 WeightedResponseTimeRule：该策略是对RoundRobinRule的扩展，增加了根据实例的响应时间来计算权重，并从权重中选择对应的实例。该策略实现主要有三个核心内容 定时任务 WeightedResponseTimeRule策略在初始化的时候会启动一个定时任务，默认每隔30秒计算一次每个服务实例的权重 权重计算 累计所有实例的响应时间，得到总的totalResponseTime，然后为实例清单中的每个实例逐个计算权重，计算公式为 weightSoFar = weightSoFar + totalResponseTime - 该实例的平均响应时间 weightSoFar 起始为零 例子 有A，B，C，D四个实例，他们的平均响应时间是10,40,80,100， 计算总的响应时间10+40+80+100 =230 计算各个实例的权重 A: 230-10=220 B:220+(230-40)=410 C:410+(230-80)=560 D:560+(230-100)=690; 计算各个实例的权重区间 A:[0,220] B:(220,410] C:(410,560] D:(560,690) 实例选择 WeightedResponseTimeRule策略会在[0,最大权重值)之间随机选取一个数，然后在看这个数落在哪个实例的权重区间内，接着WeightedResponseTimeRule就会去选择该实例。 ClientConfigEnableRoundRobinRule：该策略一般不直接使用，有些高级的策略会继承该类，完成一些高级的策略，ClientConfigEnableRoundRobinRule策略默认使用 RoundRibinRule的线性轮询机制 BestAvailableRule策略继承ClientConfigEnableRoundRobinRule，通过遍历负载均衡中维护的所有服务实例，会过滤掉故障实例，并找出并发数请求数最小的实例，所以该策略的特性就是选出最空闲的实例 PredicateBasedRule策略继承ClientConfigEnableRoundRobinRule，该策略主要特性是“先过滤，在轮询”，也就是先过滤掉一些实例，得到过滤后的实例清单，然后轮询该实例清单，PredicateBasedRule中“过滤”功能没有实现，需要继承它的类完成，也就是说不同继承PredicateBasedRule的类有不同的“过滤特性” AvailabilityFilteringRule策略继承PredicateBasedRule策略的“先过滤，在轮询”特性， AvailabilityFilteringRule策略的过滤特性是 1：是否故障，即断路器是否生效已断开 2：实例的并发请求数大于阈值，默认2的32次方减一，该阈值可以通过 <clientName>.<nameSpace>.ActiveConnectionsLimit来设置，只要满足其中一个那么就会过滤掉

我写了她的第十次今日 和实践的东西，我要说 但她走过来 我失去了我的神经 我跟她回到了她的甜品 现在我知道我正在使用 这是好男人的事业我喜欢虐待 我知道她跟我玩 这没关系，我有事业没有自尊 我们计划在晚上外出 本人等到2然后我又轻了 所有这些反对的让我如此之低 如果她让我只是它可能会告诉她，以便 当她说她只是我 比我想知道为什么她睡我的朋友 当她说，我就像一个疾病 那么我想知道多少我可以站在 那么我想我应该坚持为自己 但我真的认为这是更好的这种方式 你越是遭受 越表明你真的关心吗？ 现在我要与这个有点 这种情况比我更愿意承认 深夜，她在我的门口敲门 酒后再次和寻求评分 现在我知道我应该说没有 但这种况很难当她准备好了 我也许是的，但我不是一个dweeb 我只是一个盘有自尊 当她说她只是我 比我想知道为什么我的朋友 当她说，我就像一个 那么我想知道多我可以站在 那想我应该坚持为自己 真的是更好的这种方式 你越受 越表明你真的关心吗？

Retrofit能够支持接口的方式发起http请求，类似于Feign申明式接口调用。 目前，java常用的开发框架是springboot，遗憾的是Retrofit官方并不支持。但是，有位开发者做了增强。 注意：@Field 必须结合@FormUrlEncoded注解一起使用，否则post请求无法接收参数 修改日志策略global-log-strategy：body 响应结果 Retrofit 请求参数支持Map，详细查看官网

@Valid 只能用来验证 @RequestBody 标注的参数

mysqlspring mvc db.properties:driver=com.mysql.jdbc.Driver url=jdbc:mysql://114.215.207.30:3306busticket?useUnicode=true&characterEncoding=UTF-8username=PBDBpassword=PBDB springmvc-servlet.xml: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd ">严重: Servlet.service() for servlet [springmvc] in context with path [/Test] threw exception [Request processing failed; nested exception is org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException: Error querying database. Cause: org.springframework.jdbc.CannotGetJdbcConnectionException: Could not get JDBC Connection; nested exception is org.apache.commons.dbcp.SQLNestedException: Cannot load JDBC driver class "com.mysql.jdbc.Driver "The error may exist in com/aowin/dao/CardMapper.xmlThe error may involve com.aowin.dao.CardMapper.selectThe error occurred while executing a queryCause: org.springframework.jdbc.CannotGetJdbcConnectionException: Could not get JDBC Connection; nested exception is org.apache.commons.dbcp.SQLNestedException: Cannot load JDBC driver class "com.mysql.jdbc.Driver "] with root causejava.lang.ClassNotFoundException: com.mysql.jdbc.Driver at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1714) at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1559) at org.apache.commons.dbcp.BasicDataSource.createConnectionFactory(BasicDataSource.java:1420) at org.apache.commons.dbcp.BasicDataSource.createDataSource(BasicDataSource.java:1371) at org.apache.commons.dbcp.BasicDataSource.getConnection(BasicDataSource.java:1044) at org.springframework.jdbc.datasource.DataSourceUtils.doGetConnection(DataSourceUtils.java:111) at org.springframework.jdbc.datasource.DataSourceUtils.getConnection(DataSourceUtils.java:77) at org.mybatis.spring.transaction.SpringManagedTransaction.openConnection(SpringManagedTransaction.java:80) at org.mybatis.spring.transaction.SpringManagedTransaction.getConnection(SpringManagedTransaction.java:66) at org.apache.ibatis.executor.BaseExecutor.getConnection(BaseExecutor.java:271) at org.apache.ibatis.executor.SimpleExecutor.prepareStatement(SimpleExecutor.java:69) at org.apache.ibatis.executor.SimpleExecutor.doQuery(SimpleExecutor.java:56) at org.apache.ibatis.executor.BaseExecutor.queryFromDatabase(BaseExecutor.java:259) at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:132) at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:105) at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:81) at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:104) at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:98) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:355) at com.sun.proxy.$Proxy14.selectList(Unknown Source) at org.mybatis.spring.SqlSessionTemplate.selectList(SqlSessionTemplate.java:195) at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:114) at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:58) at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:43) at com.sun.proxy.$Proxy15.select(Unknown Source) at com.aowin.service.imp.SelectImp.select(SelectImp.java:53) at com.aowin.controller.CardController.chong(CardController.java:49) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:222) at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:137) at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:110) at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:814) at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:737) at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85) at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:959) at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:893) at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:969) at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:871) at javax.servlet.http.HttpServlet.service(HttpServlet.java:647) at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:845) at javax.servlet.http.HttpServlet.service(HttpServlet.java:728) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:305) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210) at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222) at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123) at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472) at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171) at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99) at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:953) at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118) at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408) at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1008) at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:589) at org.apache.tomcat.util.net.AprEndpoint$SocketProcessor.run(AprEndpoint.java:1852) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) at java.lang.Thread.run(Thread.java:745)

BARREN SPRING, from The First Wife and Other Stories, by Pearl Sydenstricker Buck, New York, The John Day Company, 1933, pp. 279-283. Pearl Sydenstricken Buck (1892-1973), American novelist. Her parents were missionaries in China, so she was brought up in our country. She was married, first, to John Lossing Buck, at one time professor of Rural Economics at the University of Nanking. This early part of her life she included in her biography of her mother, in her novel The Exile, published in 1935. In the same year she divorced her husband to marry her present husband Richard J. Walsh, owner of the John Day Publishing House. She still writes under the name of Mrs. Pearl S. Buck. The Good Earth, generally considered as her best novel on China, was awarded the Pulitzer Prize in 1931 for being the best novel published for that year in America. Liu, the farmer, sat at the door of his one-room house. It was a warm evening in late February, and in his thin body he felt the coming of spring. How he knew that the time had now come when sap should stir in trees and life begin to move in the soil he could not have told himself. In other years it would have been easy enough. He could have pointed to the willow trees about the house, and shown the swelling buds. But there were no more trees now. He had cut them off during the bitter winter when they were starving for food and he had sold them one by one. Or he might have pointed to the pink-tipped buds of his three peach trees and his six apricot trees that his father had planted in his day so that now, being at the height of their time, they bore a load of fruit every year. But these trees were also gone. Most of all, in any other year than this he might have pointed to his wheat fields, where he planted wheat in the winter when the land was not needed for rice, and where, when spring was moving into summer, he planted the good rice, for rice was his chief crop. But the land told nothing, this year. There was no wheat on it, for the flood had covered it long after wheat should have been planted, and it lay there cracked and like clay but newly dried. Well, on such a day as this, if he had his buffalo and his plow as he had always had in other years, he would have gone out and plowed up that cracked soil. He ached to plow it up and make it look like a field again, yes, even though he had not so much as one seed to put in it. But he had no buffalo. If anyone had told him that he would eat his own water buffalo that plowed the good land for him, and year after year pulled the stone roller over the grain and threshed it at harvest he would have called that man idiot. Yet it was what he had done. He had eaten his own water buffalo, he and his wife and his parents and his four children, they had all eaten the buffalo together. But what else could they do on that dark winter"s day when the last of their store of grain was gone, when the trees were cut and sold, when he had sold everything, even the little they had saved from the flood, and there was nothing left except the rafters of the house they had and the garments they wore? Was there sense in stripping the coat off one"s back to feed one"s belly? Besides, the beast was starving also, since the water had covered even the grass lands, and they had had to go far afield to gather even enough to cook its bones and flesh. On that day when he had seen the faces of his old parents set as though dead, on that day when he had heard the crying of his children and seen his little daughter dying, such a despair had seized him as made him like a man without his reason, so that he had gathered together his feeble strength and he had done what he said he never would; he had taken the kitchen knife and gone out and killed his own beast. When he did it, even in his despair, he groaned, for it was as though he killed his own brother. To him it was the last sacrifice. Yet it was not enough. No, they grew hungry again and there was nothing left to kill. Many of the villagers went south to other places, or they went down the river to beg in the great cities. But he, Liu the farmer, had never begged. Moreover, it seemed to him then that they must all die and the only comfort left was to die on their own land. His neighbor had come and begged him to set forth with them; yes, he had even said he would carry one of the old parents on his back so that Liu might carry the other, seeing that his own old father was already dead. But Liu had refused, and it was well, for in the next two days the old mother was dead, and if she had died on the way he could only have cast her by the roadside lest the others be delayed and more of them die. As it was he could put her safely into their own ground, although he had been so weak that it had taken him three days to dig a hole deep enough for her little old withered body. And then before he could get her buried he and his wife had quarreled over the poor few clothes on the old body. His wife was a hard woman and she would have buried the old mother naked, if he had let her, so as to have the clothes for the children. But he made her leave on the inner coat and trousers; although they were only rags after all, and when he saw the cold earth against his old mother"s flesh—well, that was sorrow for a man, but it could not be helped. Three more he had buried somehow, his old father and his baby daughter and the little boy who had never been strong. That was what the winter"s famine had taken from them. It would have taken them all except that in the great pools lying everywhere, which were left from the flood, there were shrimps, and these they had eaten raw and were still eating, although they were all sick with a dysentery that would not get well. In the last day or so his wife had crawled out and dug a few sprouting dandelions. But there was no fuel and so they also were eaten raw. But the bitterness was good after the tasteless flesh of the raw shrimps. Yes, spring was coming. He sat on heavily, looking out over his land. If he had his buffalo back, if he had his plow that they had burned for fuel, he could plow the land. But when he thought of this as he did many times every day, he felt helpless as a leaf tossed upon the flood. The buffalo was gone; gone also his plow and every implement of wood and bamboo, and what other had he? Sometimes in the winter he had felt grateful that at least the flood had not taken all the house as it had so many other houses. But now suddenly it came to him that he could be grateful for nothing, no, not even that he had his life left him and the life of his wife and the two older children. He felt tears come into his eyes slowly as they had not even come when he buried his old mother and saw the earth fall against her flesh, bared by the rags which had comforted him that day. But now he was comforted by nothing. He muttered to himself. “I have no seed to plant in the land. There the land lies! I could go and claw it up with my hands if I had the seed and the land would bear. I know my good land. But I have no seed and the land is empty. Yes, even though spring comes, we must still starve!” And he looked, hopeless, into the barren spring. 参考译文 【作品简介】 《贫瘠的春天》一文选自赛珍珠所著《第一任妻子和其他故事》，纽约约翰·戴出版公司1933年出版，279—283页。 【作者简介】 赛珍珠（1892—1973），美国小说家，因其父母曾在中国传教而生长于中国。她的首任丈夫卜凯曾任金陵大学（现南京大学前身）农业经济学教授。赛珍珠在其1935年出版的为母亲所写的传记《流亡者》中提及了自己的这段早年经历。是年，她与卜凯离婚，并嫁给后来的丈夫，约翰·戴出版公司的所有人理查德·沃尔什。她以赛珍珠的笔名创作的小说《大地》1931年获普利策奖，被评为当年在美国出版的最佳小说，也被认为是赛珍珠关于中国的小说中最出色的一部。 1　贫瘠的春天 农民老刘坐在自己只有一间房的门口。那是二月末的一个温煦的黄昏，他瘦削的身体已经感知到春天的来临。他怎会知道正是这时候树木的汁液开始颤动，泥土中的生命开始苏醒呢？他无法给自己一个答案。可是在往年，这本是一件极容易的事情。他本可以指着屋子四周的柳树，给大家看就要抽条的嫩芽。但是现在树已经没有了，严冬饥荒时被他全砍了，一棵一棵地卖了。或者他本来还可以指着父亲年轻时亲手栽种的三株桃树和六棵杏树，给大家看那粉嫩的花苞。这些果树正值壮年，每年都会结下累累的果实。但是这些树也没有了。最重要的是，往年他还会指着麦地给大家看。在这块地上，他冬天种麦子，因为那个时令没法种水稻；快入夏时，他就会插秧种稻子，而且收成很好。水稻是他田里的主要农作物。但是今年地里啥也没有。没有离离的麦子，因为该种麦子的时候，田地被洪水淹没了，现在地都开裂了，像刚干不久的黏土一样。 好吧，在这样一个日子里，要是还和往年一样，他的水牛还在，耕犁还在，他应该早已经出门去耕种那片已经开裂的土地了。他很想念犁地，想念平整耕田的样子，是的，就算他连一颗可以播撒的种子也没有。但如今他没有水牛了。要是先前有人劝他把他的水牛宰了吃，他一定会痛骂那个人是个王八犊子。他的水牛可是耕地能手，丰收时还可以帮拉石磨碾谷子。但这都是过去时了。他已经吃掉了自己的水牛。他和他的妻子、父母还有四个孩子一起把水牛给吃了。 但是，在那个昏暗的冬日里，他们吃完了储藏的最后一点粮食，树也砍光了卖钱，能卖的都卖了，连从洪水中救出的那一点点东西也都卖了，除了房梁和身上的衣服，什么都没有剩下，他们还能怎么办？剥掉衣服来填肚子有意义吗？而且当时牲口也已快饿死了，因为洪水已淹没草地，连煮牲口的骨和肉所需的柴草也得走很远才能捡够。那一天，他看到自己年迈的父母面如死灰，听到孩子们哭泣不停，眼见小女儿奄奄一息，他被一阵惨痛的绝望钳住，变得失去了理智，然后鼓起虚弱的气力，做了他说过永远不会做的事情。他到厨房拿起刀，走出去，把自己的牲口给宰了。那一刻他绝望地呻吟着，好像亲手杀了自己的兄弟。对他而言，这是最后的牺牲。 但这还不够。是的，他们又开始遭受饥饿的折磨了，但已经没有什么可杀的了。村子里很多人南下投奔别的地方，或者到河流下游的大城市去乞讨。但农民老刘绝不乞讨。而且他觉得反正大家迟早都要死，死在自己的土地上是剩下的唯一的安慰。邻居来求他，让他跟他们一起动身；是的，他的邻居看到自己的老父亲已命归黄泉时，甚至提出愿意跟老刘一道背他的父母赶路。但老刘拒绝了。这样也不错，因为两天以后他老母亲就死了。要是死在半路上，他只能把尸体扔在路边，否则还得耽误其他人的时间，然后就会有更多人因此死去。现在呢，虽说他身体已经十分虚弱，花了整整三天才挖出一个够深的土穴来掩埋母亲干瘪的身躯，但毕竟他可以把她安好地埋葬在自己的土地上。就在母亲下葬之前，他和老婆吵了一架，就为老人尸体上那点可怜的衣服。他老婆是个硬心肠的女人，假如老刘同意的话，她就要让婆婆光着身子下葬，这样一来扒下来的衣服就可以给孩子们穿。但是老刘还是给母亲穿了内衣和裤子离开了，尽管那都已经是破布了。当他看到冰冷的泥土盖在老母亲的皮肉上时——喔，这对一个男人来说是一种悲哀，但是又有什么办法呢？然后他又亲手将他的老父亲、幼小的女儿和一个从未长结实的小儿子一个个埋入泥土。 这就是这场冬日的饥荒从他们身边所夺走的。饥荒还差点夺走所有人的性命，幸亏洪水过后，随处可见的水塘里发现了小虾，他们便捞来生吃，虽然都因此得了一种难以痊愈的痢疾，但他们一直这样吃到现在。大概在最后一天，他老婆挣扎着出去，挖到了一些刚发芽的蒲公英，因为没有柴火，所以也只能生吃了。味儿苦，但在吃腻了没有滋味的生虾后，这苦味倒还感觉不错。是的，春天来了。 他一屁股坐下，望着外面自己的土地。要是他能要回他的水牛，如果他没有把耕犁当柴火烧了，他现在就能耕地了。每当他想到这些（他每天都想很多遍），他就觉得十分无助，就像扔进洪水的一片孤叶。水牛不在了，犁也不在了，连一根木头一节竹子都没有剩，他还有什么呢？冬天里，有时候他还会心存一丝感激，至少洪水没有把他所有的房屋都冲坏，尽管也冲毁了很多人家的房子。但现在，他突然意识到没有什么值得他感激的，没有，甚至他都不感激自己还活着，自己的老婆还活着，还有老大老二两个孩子。他感觉到泪水慢慢涌上眼眶，就算在埋葬母亲那天，看着泥土撒落在母亲的躯体上时，他都没有掉过一滴眼泪，他甚至还因为母亲辞世时尚有破布遮体而感到安慰。但现在，他无以慰藉。他喃喃自语： “我没有种子可以种地。土地就在那儿！我要是有种子，我会用我的双手去刨地，土地就会有收成。我知道我的地肥。但我没有种子，地里什么也没有。是的，春天来了，可我们还会挨饿！”他呆望着这贫瘠的春天，没有一丝希望。 （罗选民　译）

spring的RequestMappingHandlerAdapter中的messageConverters就能够全局格式化日期格式1. 配置spring-servlet- 引入请求映射器org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter- 加入消息转化器messageConverters- 引入Json转化器org.springframework.http.converter.json.MappingJackson2HttpMessageConverter- 实现对象转化器objectMapper- 日期转换格式定义dateFormat2. 代码<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"><property name="webBindingInitializer"><bean class="com.suixingpay.common.web.WebBindingInitializer"><property name="conversionService"><bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean"></bean></property></bean></property><property name="messageConverters"><list><bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter" /><bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"><property name="objectMapper"><bean class="com.fasterxml.jackson.databind.ObjectMapper"><property name="dateFormat"><bean class="java.text.SimpleDateFormat"><constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" /></bean></property><property name="serializationInclusion"><value type="com.fasterxml.jackson.annotation.JsonInclude.Include">NON_NULL</value></property></bean></property><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value><value>text/plain;charset=UTF-8</value><value>text/json;charset=UTF-8</value><value>application/json;charset=UTF-8</value></list></property></bean></list></property></bean>

spring boot脚手架，可以算是sprin boot的小工具。下面是spring boot官网大的介绍。Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run". We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.Spring Boot ships with a command line tool 【spring boot cli】that can be used if you want to quickly prototype with Spring. It allows you to run Groovy scripts, which means that you have a familiar Java-like syntax, without so much boilerplate code.

缺点当然有，现在 Spring 越来越大，都开始使用 Gradle 构建了，支持的东西越来越多，这就导致大多数程序员对 Spring 的体系及结构都一知半解，网上乱七八糟的文章来回粘来粘去，搞得小码农都分不清楚到底哪种使用方式是对的，这归根到底就是因为1. 对 Spring 的版本变更不清楚2. 对 Spring 和 J2EE 规范的关系不清楚3. 对 Spring 那堆配置和注解背后的原理不清楚你可能知道 DI 是个什么概念，但你可能不知道 DI 的正确使用方式：1. 你也许不知道 Spring 有自己的测试体系，我们可以直接使用2. Spring 的事务管理优越在哪里，和 Hibernate 自己的事务管理有啥区别，怎么配置才对。3. Spring 为啥提倡非侵入式（non-invasive）设计，又是从哪个版本开始这么干的，起因是什么4. Spring 那些注解的使用原理和适用场景是什么，哪些是Spring 自己的注解，哪些是 J2EE DI 的标准注解，使用哪个好，为什么好。...........上述的一切，当你把 Spring 官方提供的 Spring Reference 看的差不多了，也就明白了，大概 500 多页吧。Spring 越来越大，衍生出其他的分支项目，虽然臃肿，但如果你知道如何筛选自己想要的功能，就不会臃肿，反而会很简洁，例如：1. 你想实现 Rest 服务，那么 Spring MVC 就预置了这个功能，你没必要再去使用 CXF / Restlet 之类的 Rest 框架，还得忙着想怎么和 Spring 整合，这样，Struts 就出局了，Rest 框架也省了。2. 你想实现权限功能，那么 Spring Security 可以替你搞定，你没必要使用 Apache Shiro 来做，也没必要苦逼地自己设计，而且人家还原生支持 OAuth 和 SAML3. 你不想苦逼地写 DAO, 那么 Spring Data 可以替你做，这些 boilerplate code 全部替你实现了，而且对 JPA 或 NO-SQL 的支持也是相当方便。4. 你想根据自己的需求生成代码，而不是苦逼地自己来写，可以试试 Spring Boot...........其他的，还有很多很多，你只需要记住，是不是臃肿，很大程度上是由你的认知和使用能力决定的，不是框架本身，具体如何学习这个优秀的框架，建议：1. 视频教程点到为止，不可全信2. 网上文章看看即可，别拷过来自己完事3. 有问题，先去查看 Spring Reference, 多看原理。

Spring Awakening剧目简介：音乐剧Spring Awakening春之觉醒改编自德国剧作家Frank Wedekind写于1891年的同名舞台剧，由Duncan Sheik作曲 ，Steven Sater作词。Spring Awakening曾在2007年获得11项百老汇托尼奖（美国戏剧界的“奥斯卡”），包括最佳音乐剧、最佳导演、最佳剧本、最佳原创音乐等重要奖项。该剧的故事发生在十九世纪的德国，讲述了一群年轻人对性、对生命、对世界和自身的迷茫和探索。由于主题涉及性和暴力等话题，该剧最早的舞台剧版本在首演后相当长的时间内在德国都被禁演。剧情简介：Spring Awakening《春之觉醒》的故事发生在十九世纪思想守旧礼教严格的德国。Wendla是个单纯天真的女孩子，和她的好朋友Martha、Thea、Anna一样一直过着无忧无虑的生活，直到有一天，青春期的她发现自己的身体逐渐发生了变化……她试图向母亲寻求答案，但是母亲总是回避搪塞，不愿直面回答她的问题，这使她和有同样经历的女孩子们都感到很困扰。与她们同龄的男生Melchior、Moritz、Otto、Georg、Ernst、Hanschen青春期的生活也不轻松。在学校里，他们接受古板的教条式的教育，不得向老师和书本的权威挑战；生活中，他们也面临种种问题：升学的压力，家庭的管束，对女孩子的爱慕得不到回应……这群年轻的生命在教条、父权的压迫下，带着对世界的迷茫试图寻找自己的道路自己的方向，终如螳臂挡车般在和体制高墙的碰撞中伤得头破血流。当夏天过去，故事落幕，即使伤痕累累，失去挚友和爱人，他们仍在告诉我们，当我们找到通往梦想通往信仰的道路，希望就会降临……

假设你有一个事务，要提交两个数据库操作请求（假设请求1是在A表插入一条数据，请求2是在B表插入一条数据）。而两个请求要求要么都成功，要不成功都不执行。你可以将两个请求放在一个事务里，就可以完成上面的要求！要是不加，你怎么保证第二个数据库请求失败的时候，第一个请求回滚！

假设你有一个事务，要提交两个数据库操作请求（假设请求1是在A表插入一条数据，请求2是在B表插入一条数据）。而两个请求要求要么都成功，要不成功都不执行。你可以将两个请求放在一个事务里，就可以完成上面的要求！要是不加，你怎么保证第二个数据库请求失败的时候，第一个请求回滚！

International Journal of Information Security 是 Springer Verlag 旗下的期刊，所以 Springer 一系列的投稿系统，大致上都差不多，可能有些个别的会不一样，但不失一般性。以下环境为本帖撰写论文时，所用的文书编辑设定：latex 2.7 英文版WINEDt 5.5 英式英语llncs2e.zip Springer 完整的标准模版套件(虽然 Springer 系列的期刊很多，特定的期刊有其特定的模版，不过使用 LNCS 模版，是 Springer 最通用的，也是最广泛的。 使用 LNCS 模版， springer 出版社的排版人员能轻易也快速的转换成特定的期刊模版。)没有帐号就先到官网去注册一个帐号，然后马上收 email 后开通帐号。接着登入投稿系统投稿1 Login开始提交新的论文初稿论文的投稿别有Original Research (regular contribution)SI: Security in Cloud Computing2 Submit New Manuscript.jpg可见，现阶段，这个期刊不收 Letter, Comment, Short communication 等短文。 这是很特别的。3 Please Select an Article Type接着继续填写论文题目4 Please Enter The Full Title of Your Submission输入完论文题入后就是添加作者，在这个例子，只有单一作者，系统也默认为通讯作者。5 Please Add, Edit, or Remove Authors接着继续填写摘要6 Please Enter Abstract然后输入关键词，关键词要用分号隔开，框框上方有范例可以参考7 Please Enter Keywords这阶段是选则论文的类别及属性。选择正确的论文类别，有助于 editor 指派研究领域相同的 reviewer，若找不到相同的类别，可以选择相近的大类。8 Please Select Classifications这里，是作者补充一些叙述给编辑部门的内容；在这里，性质等同于 cover letter，框框上的说明写的很清楚。9 Please Enter Comments接下来，就是上传所有的文件。这里，我要提交的文档有 *Manuscript: typeinst.tex 及 newcite.bib Figure: 1.eps 及 2.eps Elctrical Supplemntary Material: llncs.cls 及 splncs03.bst在这里的投稿系统跟 Elsevier 会有一点差别，差别在哪里？1) 在 Elsevier 里，.bib 是要求放在 *Manuscript 那一类 而在 Springer 里，.bib 是被要求放在 Elctrical Supplemntary Materia 那一类。2) Elsevier 有 Cover Letter 那个选项，同时也有独立的 Enter Comments 阶段。 Springer 没有 Cover Letter 选项，所以作者可以把 Cover Letter 的内容放在 Enter Comments 那个阶段。3) Elsever 系统有提供 arXiv 汇入功能，且也支持一次性上传服务(Enhanced)。 Springer 系统没有提供 arXiv 汇入功能，它只支持传统 one by one 的上传功能。 10 Please Attach Files文件全部上传完毕后，检查看看是否有遗漏；若没有，就可以进行 Approval11 Needs Approval.jpgApprove 有两个阶段，一个是 View Submission，另一个是 Approve Submission12 Submissions Waiting for Author"s ApprovalView Submission 阶段，主要是检查提交上去的所有文件，经过投稿系统编译(Compiled) 后，所产生的 pdf 是否与作者在本地端所产生的内容一致？若不是，就跳回 Edit Submission 阶段。若是，则进行下一步，Approve Submission 阶段。13 View SubmissionApprove Submission 就是正式的提交论文出去，等 editor 邀请 reviewer 审稿。14 Approve Submission论文提交后，会见到 Thank you ... 的画面。15 Thank you for approving返回主选单(Author Main Menu)，会看见一篇文章正等待处理。16 Progress点进去看，就会看到状态变成 Submittd to Journal。17 Submitted to Journal后面若 editor 开始邀请 reviewer 时，画面会变成 Under Reviewer

目录 Spring 作为 Ioc 框架，实现了依赖注入，由一个中心化的 Bean 工厂来负责各个 Bean 的实例化和依赖管理。各个 Bean 可以不需要关心各自的复杂的创建过程，达到了很好的解耦效果。 我们对 Spring 的工作流进行一个粗略的概括，主要为两大环节： 我们假设所有的配置和扩展类都已经装载到了 ApplicationContext 中，然后具体的分析一下 Bean 的加载流程。 思考一个问题，抛开 Spring 框架的实现，假设我们手头上已经有一套完整的 Bean Definition Map，然后指定一个 beanName 要进行实例化，需要关心什么？即使我们没有 Spring 框架，也需要了解这两方面的知识： Spring 进行了抽象和封装，使得作用域和依赖关系的配置对开发者透明，我们只需要知道当初在配置里已经明确指定了它的生命周期和依赖了谁，至于是怎么实现的，依赖如何注入，托付给了 Spring 工厂来管理。 Spring 只暴露了很简单的接口给调用者，比如 getBean ： 那我们就从 getBean 方法作为入口，去理解 Spring 加载的流程是怎样的，以及内部对创建信息、作用域、依赖关系等等的处理细节。 上面是跟踪了 getBean 的调用链创建的流程图，为了能够很好地理解 Bean 加载流程，省略一些异常、日志和分支处理和一些特殊条件的判断。 从上面的流程图中，可以看到一个 Bean 加载会经历这么几个阶段（用绿色标记）： 整个流程最为复杂的是对循环依赖的解决方案，后续会进行重点分析。 而在我们解析完配置后创建的 Map，使用的是 beanName 作为 key。见 DefaultListableBeanFactory： BeanFactory.getBean 中传入的 name，有可能是这几种情况： 为了能够获取到正确的 BeanDefinition，需要先对 name 做一个转换，得到 beanName。 见 AbstractBeanFactory.doGetBean ： 如果是 alias name ，在解析阶段，alias name 和 bean name 的映射关系被注册到 SimpleAliasRegistry 中。从该注册器中取到 beanName。见 SimpleAliasRegistry.canonicalName ： 如果是 factorybean name ，表示这是个工厂 bean，有携带前缀修饰符 & 的，直接把前缀去掉。见 BeanFactoryUtils.transformedBeanName : 我们从配置文件读取到的 BeanDefinition 是 GenericBeanDefinition 。它的记录了一些当前类声明的属性或构造参数，但是对于父类只用了一个 parentName 来记录。 接下来会发现一个问题，在后续实例化 Bean 的时候，使用的 BeanDefinition 是 RootBeanDefinition 类型而非 GenericBeanDefinition 。这是为什么？ 答案很明显，GenericBeanDefinition 在有继承关系的情况下，定义的信息不足： 为了能够正确初始化对象，需要完整的信息才行 。需要递归 合并父类的定义 ： 见 AbstractBeanFactory.doGetBean ： 在判断 parentName 存在的情况下，说明存在父类定义，启动合并。如果父类还有父类怎么办？递归调用，继续合并。 见 AbstractBeanFactory.getMergedBeanDefinition 方法： 每次合并完父类定义后，都会调用 RootBeanDefinition.overrideFrom 对父类的定义进行覆盖，获取到当前类能够正确实例化的 全量信息 。 什么是循环依赖？ 举个例子，这里有三个类 A、B、C，然后 A 关联 B，B 关联 C，C 又关联 A，这就形成了一个循环依赖。如果是方法调用是不算循环依赖的，循环依赖必须要持有引用。 循环依赖根据注入的时机分成两种类型： 如果是构造器循环依赖，本质上是无法解决的 。比如我们准调用 A 的构造器，发现依赖 B，于是去调用 B 的构造器进行实例化，发现又依赖 C，于是调用 C 的构造器去初始化，结果依赖 A，整个形成一个死结，导致 A 无法创建。 如果是设值循环依赖，Spring 框架只支持单例下的设值循环依赖 。Spring 通过对还在创建过程中的单例，缓存并提前暴露该单例，使得其他实例可以引用该依赖。 Spring 不支持原型模式的任何循环依赖 。检测到循环依赖会直接抛出 BeanCurrentlyInCreationException 异常。 使用了一个 ThreadLocal 变量 prototypesCurrentlyInCreation 来记录当前线程正在创建中的 Bean 对象，见 AbtractBeanFactory#prototypesCurrentlyInCreation ： 在 Bean 创建前进行记录，在 Bean 创建后删除记录。见 AbstractBeanFactory.doGetBean ： 见 AbtractBeanFactory.beforePrototypeCreation 的记录操作： 见 AbtractBeanFactory.beforePrototypeCreation 的删除操作： 为了节省内存空间，在单个元素时 prototypesCurrentlyInCreation 只记录 String 对象，在多个依赖元素后改用 Set 集合。这里是 Spring 使用的一个节约内存的小技巧。 了解了记录的写入和删除过程好了，再来看看读取以及判断循环的方式。这里要分两种情况讨论。 这两个地方的实现略有不同。 如果是构造函数依赖的，比如 A 的构造函数依赖了 B，会有这样的情况。实例化 A 的阶段中，匹配到要使用的构造函数，发现构造函数有参数 B，会使用 BeanDefinitionValueResolver 来检索 B 的实例。见 BeanDefinitionValueResolver.resolveReference ： 我们发现这里继续调用 beanFactory.getBean 去加载 B。 如果是设值循环依赖的的，比如我们这里不提供构造函数，并且使用了 @Autowire 的方式注解依赖（还有其他方式不举例了）： 加载过程中，找到无参数构造函数，不需要检索构造参数的引用，实例化成功。接着执行下去，进入到属性填充阶段 AbtractBeanFactory.populateBean ，在这里会进行 B 的依赖注入。 为了能够获取到 B 的实例化后的引用，最终会通过检索类 DependencyDescriptor 中去把依赖读取出来，见 DependencyDescriptor.resolveCandidate ： 发现 beanFactory.getBean 方法又被调用到了。 在这里，两种循环依赖达成了同一 。无论是构造函数的循环依赖还是设置循环依赖，在需要注入依赖的对象时，会继续调用 beanFactory.getBean 去加载对象，形成一个递归操作。 而每次调用 beanFactory.getBean 进行实例化前后，都使用了 prototypesCurrentlyInCreation 这个变量做记录。按照这里的思路走，整体效果等同于 建立依赖对象的构造链 。 prototypesCurrentlyInCreation 中的值的变化如下： 调用判定的地方在 AbstractBeanFactory.doGetBean 中，所有对象的实例化均会从这里启动。 判定的实现方法为 AbstractBeanFactory.isPrototypeCurrentlyInCreation ： 所以在原型模式下，构造函数循环依赖和设值循环依赖，本质上使用同一种方式检测出来。Spring 无法解决，直接抛出 BeanCurrentlyInCreationException 异常。 Spring 也不支持单例模式的构造循环依赖 。检测到构造循环依赖也会抛出 BeanCurrentlyInCreationException 异常。 和原型模式相似，单例模式也用了一个数据结构来记录正在创建中的 beanName。见 DefaultSingletonBeanRegistry : 会在创建前进行记录，创建化后删除记录。 见 DefaultSingletonBeanRegistry.getSingleton 记录和判定的方式见 DefaultSingletonBeanRegistry.beforeSingletonCreation ： 这里会尝试往 singletonsCurrentlyInCreation 记录当前实例化的 bean。我们知道 singletonsCurrentlyInCreation 的数据结构是 Set，是不允许重复元素的， 所以一旦前面记录了，这里的 add 操作将会返回失败 。 比如加载 A 的单例，和原型模式类似，单例模式也会调用匹配到要使用的构造函数，发现构造函数有参数 B，然后使用 BeanDefinitionValueResolver 来检索 B 的实例，根据上面的分析，继续调用 beanFactory.getBean 方法。 所以拿 A，B，C 的例子来举例 singletonsCurrentlyInCreation 的变化，这里可以看到和原型模式的循环依赖判断方式的算法是一样： 单例模式下，构造函数的循环依赖无法解决，但设值循环依赖是可以解决的 。 这里有一个重要的设计： 提前暴露创建中的单例 。 我们理解一下为什么要这么做。 还是拿上面的 A、B、C 的的设值依赖做分析， => 1. A 创建 -> A 构造完成，开始注入属性，发现依赖 B，启动 B 的实例化 => 2. B 创建 -> B 构造完成，开始注入属性，发现依赖 C，启动 C 的实例化 => 3. C 创建 -> C 构造完成，开始注入属性，发现依赖 A 重点来了，在我们的阶段 1中， A 已经构造完成，Bean 对象在堆中也分配好内存了，即使后续往 A 中填充属性（比如填充依赖的 B 对象），也不会修改到 A 的引用地址。 所以，这个时候是否可以 提前拿 A 实例的引用来先注入到 C ，去完成 C 的实例化，于是流程变成这样。 => 3. C 创建 -> C 构造完成，开始注入依赖，发现依赖 A，发现 A 已经构造完成，直接引用，完成 C 的实例化。 => 4. C 完成实例化后，B 注入 C 也完成实例化，A 注入 B 也完成实例化。 这就是 Spring 解决单例模式设值循环依赖应用的技巧。流程图为： 为了能够实现单例的提前暴露。Spring 使用了三级缓存，见 DefaultSingletonBeanRegistry ： 这三个缓存的区别如下： 从 getBean("a") 开始，添加的 SingletonFactory 具体实现如下： 可以看到如果使用该 SingletonFactory 获取实例，使用的是 getEarlyBeanReference 方法，返回一个未初始化的引用。 读取缓存的地方见 DefaultSingletonBeanRegistry : 先尝试从 singletonObjects 和 singletonFactory 读取，没有数据，然后尝试 singletonFactories 读取 singletonFactory，执行 getEarlyBeanReference 获取到引用后，存储到 earlySingletonObjects 中。 这个 earlySingletonObjects 的好处是，如果此时又有其他地方尝试获取未初始化的单例，可以从 earlySingletonObjects 直接取出而不需要再调用 getEarlyBeanReference 。 从流程图上看，实际上注入 C 的 A 实例，还在填充属性阶段，并没有完全地初始化。等递归回溯回去，A 顺利拿到依赖 B，才会真实地完成 A 的加载。 获取到完整的 RootBeanDefintion 后，就可以拿这份定义信息来实例具体的 Bean。 具体实例创建见 AbstractAutowireCapableBeanFactory.createBeanInstance ，返回 Bean 的包装类 BeanWrapper，一共有三种策略： 使用工厂方法创建，会先使用 getBean 获取工厂类，然后通过参数找到匹配的工厂方法，调用实例化方法实现实例化，具体见 ConstructorResolver.instantiateUsingFactoryMethod ： 使用有参构造函数创建，整个过程比较复杂，涉及到参数和构造器的匹配。为了找到匹配的构造器，Spring 花了大量的工作，见 ConstructorResolver.autowireConstructor ： 使用无参构造函数创建是最简单的方式，见 AbstractAutowireCapableBeanFactory.instantiateBean : 我们发现这三个实例化方式，最后都会走 getInstantiationStrategy().instantiate(...) ，见实现类 SimpleInstantiationStrategy.instantiate ： 虽然拿到了构造函数，并没有立即实例化。因为用户使用了 replace 和 lookup 的配置方法，用到了动态代理加入对应的逻辑。如果没有的话，直接使用反射来创建实例。 创建实例后，就可以开始注入属性和初始化等操作。 但这里的 Bean 还不是最终的 Bean。返回给调用方使用时，如果是 FactoryBean 的话需要使用 getObject 方法来创建实例。见 AbstractBeanFactory.getObjectFromBeanInstance ，会执行到 doGetObjectFromFactoryBean ： 实例创建完后开始进行属性的注入，如果涉及到外部依赖的实例，会自动检索并关联到该当前实例。 Ioc 思想体现出来了。正是有了这一步操作，Spring 降低了各个类之间的耦合。 属性填充的入口方法在 AbstractAutowireCapableBeanFactory.populateBean 。 可以看到主要的处理环节有： 如果我们的 Bean 需要容器的一些资源该怎么办？比如需要获取到 BeanFactory、ApplicationContext 等等。 Spring 提供了 Aware 系列接口来解决这个问题。比如有这样的 Aware： Spring 在初始化阶段，如果判断 Bean 实现了这几个接口之一，就会往 Bean 中注入它关心的资源。 见 AbstractAutowireCapableBeanFactory.invokeAwareMethos : 在 Bean 的初始化前或者初始化后，我们如果需要进行一些增强操作怎么办？ 这些增强操作比如打日志、做校验、属性修改、耗时检测等等。Spring 框架提供了 BeanPostProcessor 来达成这个目标。比如我们使用注解 @Autowire 来声明依赖，就是使用 AutowiredAnnotationBeanPostProcessor 来实现依赖的查询和注入的。接口定义如下： 实现该接口的 Bean 都会被 Spring 注册到 beanPostProcessors 中， 见 AbstractBeanFactory : 只要 Bean 实现了 BeanPostProcessor 接口，加载的时候会被 Spring 自动识别这些 Bean，自动注册，非常方便。 然后在 Bean 实例化前后，Spring 会去调用我们已经注册的 beanPostProcessors 把处理器都执行一遍。 这里使用了责任链模式，Bean 会在处理器链中进行传递和处理。当我们调用 BeanFactory.getBean 的后，执行到 Bean 的初始化方法 AbstractAutowireCapableBeanFactory.initializeBean 会启动这些处理器。 自定义初始化有两种方式可以选择： 见 AbstractAutowireCapableBeanFactory.invokeInitMethods ： Bean 已经加载完毕，属性也填充好了，初始化也完成了。 在返回给调用者之前，还留有一个机会对 Bean 实例进行类型的转换。见 AbstractBeanFactory.doGetBean ： 抛开一些细节处理和扩展功能，一个 Bean 的创建过程无非是： 获取完整定义 -> 实例化 -> 依赖注入 -> 初始化 -> 类型转换。 作为一个完善的框架，Spring 需要考虑到各种可能性，还需要考虑到接入的扩展性。 所以有了复杂的循环依赖的解决，复杂的有参数构造器的匹配过程，有了 BeanPostProcessor 来对实例化或初始化的 Bean 进行扩展修改。 先有个整体设计的思维，再逐步击破针对这些特殊场景的设计，整个 Bean 加载流程迎刃而解。

struts负责前台的呈现层，hibernate负责后台数据库的持久层，spring则是处理业务逻辑，具体的你就下载点文档看看，当你用ssh完成一个项目时你就会有一定的了解的

下载spring2.5包肯定有

因为如果没有配置版本号，取的就是当前jar里的XSD文件，减少了各种风险。 而且 这样约定大于配置的方式很优雅。参考：http://stackoverflow.com/questions/10768873/spring-di-applicationcontext-xml-how-exactly-is-xsischemalocation-used http://stackoverflow.com/questions/11174286/spring-xml-namespaces-how-do-i-find-what-are-the-implementing-classes-behind-t http://docs.spring.io/spring/docs/current/spring-framework-reference/html/extensible-xml.html

因为如果没有配置版本号，取的就是当前jar里的XSD文件，减少了各种风险。 而且 这样约定大于配置的方式很优雅。其实，对于程序员来说，最大的好处是，当你升级了Spring的jar，该配置文件的XSD声明部分也不用改，会自动找到最新的本地jar里的XSD声明。（Spring做了特殊处理，保证断网的情况下不写XSD版本号，能找到本地的jar文件)

xsi:schemaLocation 里指明了schema的位置的。 一般来说，是xml解析时，需要验证格式时才用到这些。 或者有些编辑器 在编辑时 自动提示 根据上面来。 如果本地缓存没有，就要从网上下载了。但是没有开验证的时候xml也可以被处理。

有时候你会发现过去一直启动正常的系统，某天启动时会报出形如下面的错误：org.xml.sax.SAXParseException: schema_reference.4:Failed to read schema document "http://www.springframework.org/schema/beans/spring-beans-2.0.xsd", because1) could not find the document; 2) the document could not be read; 3) the root element of the document is not <xsd:schema>.很显然，spring xml配置文件中指定的xsd文件读取不到了，原因多是因为断网或spring的官网暂时无法连接导致的。 你可以通过在浏览器输入xsd文件的URL，如：http://www.springframework.org/schema/beans/spring-beans-2.0.xsd 进行确认。关于这个问题，网上有两种常见的解决方法，第一种简单有效，但是工作量大，即：把所有spring配置文件中url形式的xsd路径转换成指向本地xsd文件的classpath形式的路径，例如：classpath:org/springframework/beans/factory/xml/spring-beans-2.5.xsd ,再有一种方法就是在本机搭建web服务器，按URL创建相应文件夹，放入对应xsd文件，在本机hosts文件中加入"127.0.0.1 www.springframework.org".实际上，这两种方法都属于“歪打正着”式的方法，直正弄明白这一问题还需要从spring的XSD文件加载机制谈起。首先：你必须知道一点：spring在加载xsd文件时总是先试图在本地查找xsd文件(spring的jar包中已经包含了所有版本的xsd文件)，如果没有找到，才会转向去URL指定的路径下载。这是非常合理的做法，并不像看上去的那样，每次都是从站点下载的。事实上，假如你的所有配置是正确定的，你的工程完全可以在断网的情况下启动而不会报上面的错误。Spring加载xsd文件的类是PluggableSchemaResolver，你可以查看一下它的源码来验证上述说法。另外，你可以在log4j.xml文件中加入：<logger name="org.springframework.beans.factory.xml"> <level value="all" /> </logger>通过日志了解spring是何加载xsd文件的。接下来，问题就是为什么spring在本地没有找到需要的文件，不得不转向网站下载。关于这个问题，其实也非常简单。在很多spring的jar包里，在META-INF目录下都有一个spring.schemas，这是一个property文件，其内容类似于下面：

spring up like mushrooms雨后春笋双语对照词典结果：spring up like mushroomsv.雨后春笋般地涌现; 例句:1.Clouds usually look like mushrooms before a thunderstorm. 暴风雨来临之前的云层通常都会像蘑菇云。.-----------------------------------如有疑问欢迎追问！满意请点击右上方【选为满意回答】按钮

@Autowired作用相当于@Resource，只是@Autowired按byType（先按类型匹配，匹配不了再按名称）自动注入，@Resource按byName自动注入

spring框架中domain是什么意思？用在什么时候？

对于普通的Java对象，当new的时候创建对象，当它没有任何引用的时候被垃圾回收机制回收。而由Spring IoC容器托管的对象，它们的生命周期完全由容器控制。Spring中每个Bean的生命周期如下：1. 实例化Bean对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。 对于ApplicationContext容器，当容器启动结束后，便实例化所有的bean。 容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化，并未进行依赖注入。 实例化对象被包装在BeanWrapper对象中，BeanWrapper提供了设置对象属性的接口，从而避免了使用反射机制设置属性。2. 设置对象属性（依赖注入）实例化后的对象被封装在BeanWrapper对象中，并且此时对象仍然是一个原生的状态，并没有进行依赖注入。 紧接着，Spring根据BeanDefinition中的信息进行依赖注入。 并且通过BeanWrapper提供的设置属性的接口完成依赖注入。3. 注入Aware接口紧接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给bean。4. BeanPostProcessor当经过上述几个步骤后，bean对象已经被正确构造，但如果你想要对象被使用前再进行一些自定义的处理，就可以通过BeanPostProcessor接口实现。 该接口提供了两个函数：postProcessBeforeInitialzation( Object bean, String beanName ) 当前正在初始化的bean对象会被传递进来，我们就可以对这个bean作任何处理。 这个函数会先于InitialzationBean执行，因此称为前置处理。 所有Aware接口的注入就是在这一步完成的。postProcessAfterInitialzation( Object bean, String beanName ) 当前正在初始化的bean对象会被传递进来，我们就可以对这个bean作任何处理。 这个函数会在InitialzationBean完成后执行，因此称为后置处理。5. InitializingBean与init-method当BeanPostProcessor的前置处理完成后就会进入本阶段。 InitializingBean接口只有一个函数：afterPropertiesSet()这一阶段也可以在bean正式构造完成前增加我们自定义的逻辑，但它与前置处理不同，由于该函数并不会把当前bean对象传进来，因此在这一步没办法处理对象本身，只能增加一些额外的逻辑。 若要使用它，我们需要让bean实现该接口，并把要增加的逻辑写在该函数中。然后Spring会在前置处理完成后检测当前bean是否实现了该接口，并执行afterPropertiesSet函数。当然，Spring为了降低对客户代码的侵入性，给bean的配置提供了init-method属性，该属性指定了在这一阶段需要执行的函数名。Spring便会在初始化阶段执行我们设置的函数。init-method本质上仍然使用了InitializingBean接口。6. DisposableBean和destroy-method和init-method一样，通过给destroy-method指定函数，就可以在bean销毁前执行指定的逻辑

ssh结构里,scope应该设置为Singleton还是Prototype 分别什么情况下用，各有什么service 用spring，用来注入。 控制器 用struts 1.当一个bean的作用域

若不使用镜像，会发现maven项目会同步半天都不成功。 https://www.cnblogs.com/dengbo/p/12003667.html pom.xml报错日志： getInputStream() must not be called against a directory: apache-maven-3.6.3/conf 通过修改application.yml文件即可，注意SpringBoot2.0前后的写法不一样。 https://blog.csdn.net/Javaer_dog/article/details/83153613 2.0及之前： server.context-path=/myprojectname 2.0之后： server.servlet.context-path=/myprojectname 而且还有个重点我要强调： key与value之间一定要空格 。 建议远程部署war包之前，先在本地Tomcat部署测试，再去远程部署测试。 下面的都是打war包然后部署 https://blog.csdn.net/shaoyedeboke/article/details/90454494 https://blog.csdn.net/zhanglf02/article/details/86313540 https://www.cnblogs.com/sanjay/p/11818436.html https://www.licoy.cn/2887.html/amp https://www.jianshu.com/p/baf624064540 上面的这些博客说的可能千奇百怪，我实践总结了一下，就两点： 1）pom.xml配置打包类型为war <packaging>war</packaging> 2）定义ServletInitializer类 定义ServletInitializer类，和Application同一目录： 当然也可以把这个configure方法直接写到Application类里。 3）生成war包放到tomcat里 第一步： pom.xml里添加依赖 第二步：写html 怎么让html适配手机的大小： https://blog.csdn.net/jacob_ios/article/details/79739536 在<head>里添加 <meta charset="UTF-8" name="viewport" content="width=device-width, height=device-height, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no"> 第三步：配置application.yml文件 这里的mode: LEGACYHTML5需要依赖第一步pom.xml中依赖的nekohtml，代表不是严格规范的HTML5，否则html5很容易报错。 第四步：新建Controller 1)注意@Controller不是@RestController，后者这个接口会返回普通的字符串，而不是一个网页。 2)注意pom.xml中的 spring-boot-starter-thymeleaf ，没有这个的话，接口会报404。 电脑经常性的重启，导致IDEA意外关闭，然后项目就不被识别为Maven项目了，View-ToolWindow-MavenProject就没有这个选项。application.yml修改也没有生效。 解决办法：关闭项目重新import导入即可

Kings of the pussy, pounding our brewskies,Banging chicks right there in the sand,Bros before hoes and chicks with no clothes andSlammin" shots and marry a man!Who wanna do a shot? (we do),I"m gonna get fucked up (me too),We came for a week, we are kings of the beach,Spray water on the girls, t-shirts (See-through),Cancun, party down, Lauderdale, another round,Havasu, crack a brew, marry a man!Pranks when you"re passed out, jokes about roofies,Making girls kiss, marry a man!Giant sombreros, show us your titties,Creatine shakes, marry a man!(SPRING BREAK Y"ALL! )Oh shit! I"m too fucked up! Puke and rally, that"s what"s up!Booze cruise, raise your glass, snort that coke off her ass!Two chicks at the dance hall, take it to the dance stalls,Trade these beads for their braaa!SoCo in my Canteen, got girls jumpin" on the trampoline,Two men bound by the laaaw!Trashing hotel rooms, clogging up toilets,Beer goggles if she"s a hag,Planning the menu, picking out flowers,Nailing sluts and writing our vows!Down here it"s our time! Springbreakers, let"s get fucked up!Then find Mr. Right and get monogamous,Picking our invite font as a twosome,Something tasteful but not too bland,Seating arrangements, charming the in laws,Ripping beer bongs, sex with a man!We"ll be so happy, true love forever,Two kings walking hand in hand,Promise to cherish, trust and respect him,Crushing pussy, marry a man!(Spring... break! )Kings of the pussy, pounding our brewskies,猫咪的国王,我们brewskies捣碎,Banging chicks right there in the sand,敲打着小鸡在沙滩上,Bros before hoes and chicks with no clothes and没有衣服和兄弟在锄头和小鸡Slammin" shots and marry a man!Slammin”的照片和结婚的一个男人!Who wanna do a shot? (we do),谁想做一枪?(我们做),I"m gonna get fucked up (me too),我要毙了(我也是),We came for a week, we are kings of the beach,我们来了一个星期,我们国王的海滩,Spray water on the girls, t-shirts (See-through),喷淋水的女孩,t恤(透明的),Cancun, party down, Lauderdale, another round,坎昆,聚会,另一轮,劳德代尔堡Havasu, crack a brew, marry a man!Havasu,裂纹酿造,嫁给一个男人!Pranks when you"re passed out, jokes about roofies,恶作剧当你昏倒了,开玩笑饮品中,迷奸药Making girls kiss, marry a man!让女孩亲吻,嫁给一个男人!Giant sombreros, show us your titties,巨大的宽沿帽,你终于告诉我们,Creatine shakes, marry a man!肌酸摇,嫁给一个男人!(SPRING BREAK Y"ALL! )(春假偷鸡摸狗!)Oh shit! I"m too fucked up! Puke and rally, that"s what"s up!哦,狗屎!我太乱糟糟的!呕吐和集会,这是怎么了!Booze cruise, raise your glass, snort that coke off her ass!酒巡航,举起酒杯,snort,可口可乐从她的屁股!Two chicks at the dance hall, take it to the dance stalls,两个小鸡在舞厅跳舞的摊位,Trade these beads for their braaa!这些珠子的braaa贸易!SoCo in my Canteen, got girls jumpin" on the trampoline,无尘布在我的餐厅,有女孩运动员的蹦床,Two men bound by the laaaw!两个男人受laaaw !Trashing hotel rooms, clogging up toilets,破坏酒店客房,堵塞厕所,Beer goggles if she"s a hag,“啤酒眼”如果她是一个巫婆,Planning the menu, picking out flowers,规划菜单,挑选鲜花,Nailing sluts and writing our vows!钉荡妇和书写我们的誓言!Down here it"s our time! Springbreakers, let"s get fucked up!下面是我们的时间!Springbreakers,毙了吧!Then find Mr. Right and get monogamous,然后找到合适先生和一夫一妻制,Picking our invite font as a twosome,挑选我们邀请字体在一起,Something tasteful but not too bland,雅致的,但不要太平淡无奇,Seating arrangements, charming the in laws,座位安排,迷人的法律,Ripping beer bongs, sex with a man!把啤酒声音,和一个男人上床!We"ll be so happy, true love forever,我们会很开心,真爱永远,Two kings walking hand in hand,两位国王散步手牵手,Promise to cherish, trust and respect him,承诺珍惜,信任和尊重他,Crushing pussy, marry a man!猫咪,嫁给一个男人!(Spring... break! )(春天…打破!)

这个是web容器在管理吧