有做SCI翻译服务的公司吗？价格贵吗？大概什么时间可以完成？_百度知道
有做SCI翻译服务的公司吗？价格贵吗？大概什么时间可以完成？
开题报告真的好烦，不重要，但是又要花很多时间去处理，经历完全不够，找公司代写真心是个好主意，我们这边有家威斯腾生物，是做整体实验的，不知道代写开题报告否，可以联系试试!
采纳率：100%
翻译润色，包发表定制一条龙，我 会 可以
帮你。价格实惠， 翻译时间一周内。
为您推荐：
其他类似问题
sci的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。使用IntelliJ IDEA开发SpringMVC网站
最近在做某在线教育平台网站的开发，按师兄的建议要用SpringMVC来搞。之前对SpringMVC的认知度为0，网上查阅各种资料，发现五花八门的配置都有，文章写的那叫一个乱啊，我觉得有些文章还是不要发出来的比较好，简直误人子弟耽误时间。最近借着师兄网上搜集的一些开发经验，找到了IntelliJ网站上的这篇文章《》，外加看了孔老师的《》，着实有一种醍醐灌顶的感觉，整个路子瞬间通了，开发速度指数型上涨。现在把开发过程中的一些相关经验贴出来。
一、相关环境：
& & &- Intellij IDEA 14.0.3 Ultimate
& & &- Tomcat 7.0.57
& & &- JDK 1.7.0_75
& & &- Spring 3.2.0
& & &- MySql 5.6
& & &- Maven 3.2.5
& & &- Bootstrap 3.3.2
&&&& & 以上是我要做的这个demo所需要的东西，当然有些是可选的，版本也是可控的。比如说如果你用不惯Maven的话可以自行去官网下载jar包然后导入自己的工程中，如果想要学习下Maven可以看看《》（偶然找到，这个老师做的视频都挺好的，推荐以下），不用完全的去学习Maven，懂大概意思后再去找找IntelliJ IDEA如何配置maven的相关文章就足够了。
& & & 还有Bootstrap，纯粹是个人洁癖，不需要这可以去之。
& & & 事先声明，请确保IntelliJ IDEA、Tomcat、MySql和JDK都已经安装好。Maven和Bootstrap的话能有则有。前者为了让导包更容易，后者为了让页面更美观。废话不多说，正式开始
二、Maven的安装与在IntelliJ中的配置
& & 思来想去这节还是得讲讲，虽然比较简单但是很有作用。
& & 点击&&进入官网：
& & &左上角红框处点击Download便进入了下载页面，往下拉，可发现，当前版本是3.2.5，点击下面红框中的就可下载，下载后解压缩到相应目录下：
& & 接下来配几个环境变量，新增系统变量M2_HOME：即MAVEN安装目录：
&&&&在Path中加入：%M2_HOME%\ & &
&&&&至此，maven便安装好了，接下来在IntelliJ中配置Maven。在Intellij中按快捷键 ctrl+alt+s，或者选择File-Settings，进入到设置页面，在搜索框中输入maven，如下图所示：
一般如果环境变量配置好了的话，这三样IntelliJ都会默认识别的，如果未识别可能原因是你的环境变量没配好，我们确认这三样好了之后，则说明IntelliJ中Maven已经配置好了。
三、IntelliJ中配置Tomcat
&&&&为了提供完全周到的服务，还是在这里讲讲Tomcat的配置，Tomcat也属于Apache，所以安装方法与Maven相似，只是不用配置环境变量。请自行上网下载压缩包版本如
32-bit Windows zip&(pgp,&md5,&sha1)
64-bit Windows zip&(pgp,&md5,&sha1)
&&&&不建议下载安装器，解压后到\bin\目录下运行startup.bat，如图下所示，如果出现Server startup in xxxx ms说明Tomcat安装成功。
&&&&在IntelliJ中，可以选择提前配置好Tomcat，或者之后配置。
& & 提前配置的话，打开Settings，搜索Application Server，如下图所示：
&&&&点 + 号，选择Tomcat Server，导入Tomcat路径，OK，Apply，这样Tomcat就配置好了：
四、创建Maven Web项目
& & 前面说了这么多，差不多基本的东西都保障了（当然如果你还没装jdk，那文章写到这我也是泪如雨下了）。现在进入正题，如何来创建一个Web项目。对于不使用Maven的开发者，可以直接建一个简单的Web项目。使用Maven的话，请按照图进行操作。
&&&&菜单File-&New Project可进入上图界面，首先选择左边栏Maven，再配置JDK（一般如果之前添加了JDK的话会自动填充，如未添加的话点击旁边的New将JDK目录导入进来就可以）。勾选&Create from archetype&，然后选中4处蓝色位置，点Next，进入如下界面：
&&&&这里需要填写GroupId和ArtifactId还有Version，这三个属性目的是标识你的项目的唯一性，比如Tomcat的GroupId是org.apache，即它是apache组织的项目，ArtifactId是tomcat，项目名为tomcat，而我当前使用的Version是7.0.57。这些只在发布时有用，在此可以随便填写，填好后点两次Next，到如下界面：
给你的项目起个名字，然后Finish，这样一个maven管理的web项目就创建完成了，其结构如下图所示（需要等待加载一会）：
& & 左边红框中展示了该项目的文件结构。我们可以发现，它在src/main下创建了一个recources文件夹，该文件夹一般用来存放一些资源文件，还有一个webapp文件夹，用来存放web配置文件以及jsp页面等，这已经组成了一个原始的web应用。现在我们简单的运行一下，我们点击右边红框上的向下箭头，选择Edit Configuration以配置该项目的Tomcat服务器，
点击左上角的 + 号，选择Tomcat Server-&Local，进入如下界面：
&&&&先给服务器改个名，在选择Deployment，这一步相当于部署应用到Tomcat，点击右边 + 号，选择Artifact，进入如下界面：
&&&&选择war exploded那个选项，然后OK，这样猫头上的那个大X就消失了，即项目已部署完成，点击OK，如图所示：
&&&&右上角出现了Tomcat的标识，点击右边那个箭头，启动Tomcat，然后在浏览器中输入localhost:8080，出现了Hello World!，说明都已经配置好了。
五、Maven导入jar包
&&&&既然我们要用SpringMVC开发，那肯定少不了SpringMVC的相关jar包。如果不使用Maven的话，那就需要去官网下载相关的jar包，然后导入到项目中。现在使用maven的话，就不需要上网找jar包了。具体容我一一道来。
&&&&Maven所做的工作其实很简单，就是自动把你需要的jar包下载到本地，然后关联到项目中来。maven的所有jar包都是保存在几个中央仓库里面的，其实一个最常用的是，即，你需要什么jar包，它就会从仓库中拿给你。那么如何告诉maven需要什么jar包呢？我们看看工程目录，能找到一个pom.xml文件（这个文件在刚创建好项目时就已经展现在了大家面前），maven就是靠它来定义需求的，代码如下：
&project&xmlns="http://maven.apache.org/POM/4.0.0"&xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
&&xsi:schemaLocation="http://maven.apache.org/POM/4.0.0&http://maven.apache.org/maven-v4_0_0.xsd"&
&&&modelVersion&4.0.0&/modelVersion&
&&&groupId&com.gaussik&/groupId&
&&&artifactId&mooc&/artifactId&
&&&packaging&war&/packaging&
&&&version&1.0-SNAPSHOT&/version&
&&&name&mooc&Maven&Webapp&/name&
&&&url&http://maven.apache.org&/url&
&&&dependencies&
&&&&&dependency&
&&&&&&&groupId&junit&/groupId&
&&&&&&&artifactId&junit&/artifactId&
&&&&&&&version&3.8.1&/version&
&&&&&&&scope&test&/scope&
&&&&&/dependency&
&&&/dependencies&
&&&&&finalName&mooc&/finalName&
&&&/build&
&/project&
&&&&我们可以看到这个文件包含了我们之前定义的本项目的gropId等信息，这些信息是该项目的标识，我们不要去改动它们。重点看&dependencies&标签，翻译过来是&依赖&的意思，也就是说把对每个包的需求都称为一个依赖&depedency&，定义在&dependencies&中。在每个&depedency&中，你需要提供的是所需jar包的groupId、artifactId、version这三个必要信息。比如上面我们看到引入可一个junit包，格式如下：
&dependency&
&&&groupId&junit&/groupId&
&&&artifactId&junit&/artifactId&
&&&version&3.8.1&/version&
&&&scope&test&/scope&
&/dependency&
&&&&这是单元测试包，提供了三个基本信息，第4个scope对其他包来说是非必需的。所有jar包的引入都要满足这个格式。那么如何查看这些jar包的3个信息呢，可能刚接触是开发者还不是很熟悉，这个时候就需要查阅仓库了。比如我们需要引入Spring核心jar包spring-core，打开，搜索spring-core，进入如下界面：
&&&&点击进入红框选中的Spring Core，如下所示，可以看到各版本的使用情况：
&&&&先加入我们需要4.1.4.RELEASE版本的spring-core.jar，我们点击该版本，进入如下界面，发现它给出了这个版本jar包的依赖引用方法，把红框中代码复制到pom.xml的&dependicies&中后，发现右上角出现了maven的询问，是否要导入改变：
&&&&点击Import Changes，Maven就会开始自动下载jar包到本地（默认C盘，不过是可以修改的），然后关联到你的项目中，下载完成后，我们展开工程目录中External Libraries：
&&&&可以发现，虽然我们只写了一个依赖，但是它导入了两个jar包，也就是说，导入某个jar包时，与它密切相关的jar包也会同时被导入进来。
&&&&那么，除了spring-core，我还要spring-context，复制spring-core的&dependency&，将spring-core改为spring-context，如下：
&dependency&
&&&&&groupId&org.springframework&/groupId&
&&&&&artifactId&spring-context&/artifactId&
&&&&&version&4.1.4.RELEASE&/version&
&/dependency&
&&&&然后Import Changes，查看External Libraries，会不会发现，瞬间导入了好多jar包当然不是瞬间，这得看你的网速了）呢：
&&&&这就是Maven的强大之处，如果你需要使用SpringMVC开发网站的话，只需记住几个重要的包的名字，就可以轻松将所有包导入项目中。
&&&&长话短说，现在我们要进行SpringMVC的开发，请把你的pom.xml编程下面的样子，当然不要改你的grupId等信息（从modelVersion到url都不要动）：
&project&xmlns="http://maven.apache.org/POM/4.0.0"&xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
&&&&xsi:schemaLocation="http://maven.apache.org/POM/4.0.0&http://maven.apache.org/maven-v4_0_0.xsd"&
&&&&&modelVersion&4.0.0&/modelVersion&
&&&&&groupId&com.gaussik&/groupId&
&&&&&artifactId&mooc&/artifactId&
&&&&&packaging&war&/packaging&
&&&&&version&1.0-SNAPSHOT&/version&
&&&&&name&mooc&Maven&Webapp&/name&
&&&&&url&http://maven.apache.org&/url&
&&&&&properties&
&&&&&&&&&spring.version&3.2.0.RELEASE&/spring.version&
&&&&&&&&&spring-data.version&1.2.0.RELEASE&/spring-data.version&
&&&&&/properties&
&&&&&dependencies&
&&&&&/dependencies&
&&&&&build&
&&&&&&&&&finalName&mooc&/finalName&
&&&&&/build&
&/project&
&&&&请在&dependencies&中加入以下依赖：
&&&&&dependency&
&&&&&&&&&groupId&org.springframework&/groupId&
&&&&&&&&&artifactId&spring-core&/artifactId&
&&&&&&&&&version&${spring.version}&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.springframework&/groupId&
&&&&&&&&&artifactId&spring-web&/artifactId&
&&&&&&&&&version&${spring.version}&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&javax.servlet&/groupId&
&&&&&&&&&artifactId&servlet-api&/artifactId&
&&&&&&&&&version&2.5&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&javax.servlet.jsp&/groupId&
&&&&&&&&&artifactId&jsp-api&/artifactId&
&&&&&&&&&version&2.1&/version&
&&&&&&&&&scope&provided&/scope&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.springframework&/groupId&
&&&&&&&&&artifactId&spring-webmvc&/artifactId&
&&&&&&&&&version&${spring.version}&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.springframework&/groupId&
&&&&&&&&&artifactId&spring-test&/artifactId&
&&&&&&&&&version&${spring.version}&/version&
&&&&&&&&&scope&test&/scope&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&jstl&/groupId&
&&&&&&&&&artifactId&jstl&/artifactId&
&&&&&&&&&version&1.2&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.springframework.data&/groupId&
&&&&&&&&&artifactId&spring-data-jpa&/artifactId&
&&&&&&&&&version&${spring-data.version}&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.hibernate.javax.persistence&/groupId&
&&&&&&&&&artifactId&hibernate-jpa-2.0-api&/artifactId&
&&&&&&&&&version&1.0.0.Final&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.hibernate&/groupId&
&&&&&&&&&artifactId&hibernate-entitymanager&/artifactId&
&&&&&&&&&version&3.6.10.Final&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&mysql&/groupId&
&&&&&&&&&artifactId&mysql-connector-java&/artifactId&
&&&&&&&&&version&5.1.34&/version&
&&&&&/dependency&
&&&&&dependency&
&&&&&&&&&groupId&org.json&/groupId&
&&&&&&&&&artifactId&json&/artifactId&
&&&&&&&&&version&&/version&
&&&&&/dependency&
&&&&我们可以发现，除了导入了spring相关jar包，还有一些其他的包，这些包都是有作用的，我们后面慢慢说。如果不使用Maven请自行下载spring、hibernate、mysql、jstl、javax-servlet、json等相关jar包然后导入到工程中。至此，jar包的导入就完成了，我们按 ctrl+alt+shift+s，或者File-&Project Structure查看一下项目结构，看看有什么问题：
&&&&由于之后我们要开始写代码了，先做一些配置，选择Modules，在mooc的src\main文件夹中新建一个文件夹，取名为java：
选中java文件夹，点击上面的Make as：Sources，该文件夹就会变成蓝色，用以保存java代码。
六、SpringMVC实践
&&&&进行完上面的配置，那就说明现在基本的开发和运行环境已经搭建好了，现在要开始进行SpringMVC的网站开发。
。。。待续
阅读(...) 评论()
随笔 - 16522
评论 - 1553选择TopPaper的理由
不只是简单的英文润色
TopPaper的底限
TopPaper的底限是不欺骗客户，不损害客户利益。
反对华而不实，浮夸虚假
注重整体检查论文的专业性、学术逻辑
SCI轻松上路
选择TopPaper，SCI之路会更轻松一些。
cover letter 和response letter的写法
查看: 51283|
摘要: http://emuch.net/bbs/viewthread.php?tid=988184fpage=1 投稿感受和体会 by dingdang15 from emuch 投稿感受和体会 by dingdang15 from emuch几个月前认识了小木虫网站，从此就喜欢上了这里．每天有空都上这里，看一 ...
RESPONSES TO REVIEWERS’ COMMENTSDear Dr:We are truly grateful to yours and other reviewers’ critical comments and thoughtful suggestions. Based on these comments and suggestions, we have made careful modifications on the original manuscript. All changes made to the text are in red color. In addition, we have consulted native English speakers for paper revision before the submission this time. We hope the new manuscript will meet your magazine’s standard. Below you will find our point-by-point responses to the reviewers’ comments/ questions: Comments from the Editor-in-Chief: 回复后1月，要求小休，并认为英文水平已经大大提高，要求明确我下一步想如何研究，因此老外由帮我写了回复信，如下是第二封信的开场白：Dear Dr. Chernick:We must thank you and all other reviewers for the critical feedback. We feel lucky that our manuscript went to these reviewers as the valuable comments from them not only helped us with the improvement of our manuscript, but suggested some neat ideas for future studies. Please do forward our heartfelt thanks to these experts. Based on the comments we received, careful modifications have been made to the R1 manuscript. All changes were marked in red text. In addition, we also have a native English speakers double-checked the English for the revised R2 version. We hope the new manuscript will meet your magazine’s standard. Below you will find our point-by-point responses to the reviewers’ comments/ questions:
Dear Editor:Thank you very much for your supervision of the reviewing process of my manuscript (Ref. No. of XXXXXXX). We also highly appreciate the reviewer’s carefulness, conscientious, and the broad knowledge on the relevant research fields, since they have given me a number of beneficial suggestions. According to the reviewer’s instructions, we have made the following revisions on this manuscript:1. After examining the reviewer’s comments carefully, we must admit that we havenot expressed our meaning correctly in the previous manuscript. Sorry for this confusion. In the revised version, the “rougher” has been corrected as “weaker andbroader”. (See Line 7 from top, 3.1 Phase identification).2. As suggested by the reviewer, Fig. 3a has been referred into the revised manuscriptto reveal flattening of the milled powders. (See Line 4 from top, 3.2 Microstructure)3. In the review comments, the reviewer has pointed out that “The particle size of thepowders in Fig. 3b&c appear to be comparable?” We have again examined Fig. 3band 3c carefully. Compared with the particle size of powders in Fig. 3b, the particlesize of particles in Fig. 3c showed a very slight increase. (See Line 17 from top, 3.2Microstructure)4. As suggested by the reviewer, we have outlined the operating mechanism in the revised manuscript for the sake of better understanding and clarity. (See Lines 7-11 from top, 4.Conclusions)5. In the review comment, we are very appreciated to know that a marked hardcopy ofthe manuscript has been sent by post concerning additional corrections of Englishlanguage. We have waited the hardcopy for more than 2 months since May 9, 2008.However, we have not yet received the hardcopy till now, due to some unknownreasons. With the permission of XXXXXXX (Email: XXXXXXX), we have invited another native English speaker in　our university, who is a visiting professor from USA engaged in the research field of　Materials Science and Engineering, to go through the whole manuscript. The English　language in the current manuscript has been polished and improved.We hope that these revisions are satisfactory and that the revised version will beacceptable for publication in XXXXXXX.Thank you very much for your work concerning my paper.Wish you all the best!Sincerely yours,XXXXXXX
站长推荐 /5
且看TopPaper深入分析行业内幕，避免上当受骗！
加客服qq，请直接搜手机:
提供正规发票！协助报销！
1）长句翻译免费实时指导；
2）投稿问题；
3）行文思路；
照着做，你也是高手！
加qq，请直接搜手机：151
版权所有：联系方式：Vip6 QQ： （还可搜绑定的手机：151 ）；邮箱：或 手机：151将 Shiro 作为应用的权限基础
前言 是 JAVA 世界中新近出现的权限框架，较之 JAAS 和 Spring Security，Shiro 在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势。本文就带领读者一睹 Shiro 的风采。可能大家早先会见过 ，这个是 Shiro 的前身。在 2009 年 3 月初之前，这个安全框架叫做 J-security，由于某些原因，更名为 Shiro（或者 Ki，意为 Fortress），是 Apache 的孵化项目，鉴于本文编写时 Shiro 的还没有正式发布的版本，本文使用的是 Jsecurity 的稳定版本 0.9，本文中 Shiro 等同于 Jsecurity。本文将涉及 Shiro 的整体框架、安全模型、关键概念类，同时给出了 Shiro 以及 Grails Shiro Plugin 的使用示例，可以下载文中使用的源代码。本文代码的开发环境：
Grails Shiro Plugin
SpringSource Tool Suite 2.3Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：
易于理解的 Java Security API；
简单的身份认证（登录），支持多种数据源（LDAP，JDBC，Kerberos，ActiveDirectory 等）；
对角色的简单的签权（访问控制），支持细粒度的签权；
支持一级缓存，以提升应用程序的性能；
内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境；
异构客户端会话访问；
非常简单的加密 API；
不跟任何的框架或者容器捆绑，可以独立运行。目前还有其他出现较早的安全框架，比如 JAAS，Spring Security。JAAS —面世的时间最早，但是鉴于其在使用上有很大的限制，很少有人真正的使用它。可以说它不是一个好的应用程序级别的安全框架；Spring Security —目前是 Java 安全框架领域当之无愧的老大，已经非常成熟了；如果使用 Spring 框架，可以首选 Spring Security，但是对于单应用来说，Shiro 更显简单方便。下面就开始我们的 Shiro 之旅吧！整体架构首先，我们来看看的 Shiro 的整体架构，见下图：图 1. 整体架构从上图可以看出，Shiro 主要有四个组件：
SecurityManager
典型的 Facade，Shiro 通过它对外提供安全管理的各种服务。 Authenticator
对“Who are you ？”进行核实。通常涉及用户名和密码。这个组件负责收集 principals 和 credentials，并将它们提交给应用系统。如果提交的 credentials 跟应用系统中提供的 credentials 吻合，就能够继续访问，否则需要重新提交 principals 和 credentials，或者直接终止访问。 Authorizer
身份份验证通过后，由这个组件对登录人员进行访问控制的筛查，比如“who can do what”， 或者“who can do which actions”。Shiro 采用“基于 Realm”的方法，即用户（又称 Subject）、用户组、角色和 permission 的聚合体。 Session Manager
这个组件保证了异构客户端的访问，配置简单。它是基于 POJO/J2SE 的，不跟任何的客户端或者协议绑定。 Shiro 的认证和签权可以通过 JDBC、LDAP 或者 Active Directory 来访问数据库、目录服务器或者 Active Directory 中的人员以及认证 / 签权信息。SessionManager 通过会话 DAO 可以将会话保存在 cache 中，或者固化到数据库或文件系统中。安全模型从 Shiro 的框架图，已经能够体会到这个工具的简单了。下面让我们来看看 Shiro 是如何工作的。先了解一下它的安全模型吧！见下图：图 2. 安全模型上图中，涉及了 Shiro 的五个概念：
Subject 是安全领域术语，除了代表人，它还可以是应用。在单应用中，可将其视为 User 的同义词。
Principal 是 Subject 的标识，一般情况下是唯一标识，比如用户名。
Role 和 Permission 分别代表了不同粒度的权限，从上图中可以看出 Role 的粒度更大些，Permission 代表了系统的原子权限，比如数据的修改、删除权限。对于简单的权限应用，可以不需要 Permission。
Realm 是一个执行者，负责真正的认证和鉴权。实现应用的安全模块的关键在于：定义合适的 role 和 permission，这就需要遵循如下原则：
role 没有实质内容，只是代表一组 permission，目的是为了管理的方便，一般都是动态定义；
permission 一般都是预先定义好的，不允许动态改变，除非源代码改动，它才会变化，它是整个安全模块的基础；
要使 permission 也能动态定义，并非不可能，但是这将使鉴权非常复杂，甚至可能导致鉴权语句遍布整个程序，得不偿失；
当然有一个例外：如果知道 permission 动态定义的规则和鉴权规则，如 Grails 的 fileter 中“${controllerName}:${actionName}:${params.id}”也可实现 permission 的动态定义关键概念类理解 Shiro 的架构和安全模型了，我们来看看更具体些的内容。下图显示了 Shiro 中的关键概念类（参考资料 -- JSecurity Mini Guide）。图 3. 关键类AuthenticationToken 和 AuthenticationInfo前者在认证前使用，描述认证所需的信息，最常用的就是 username 和 password 对；后者在认证后使用，内容同前，但是表示已经经过认证的信息。RememberMe代表的是一种可能状态，并不表示该 Subject 已经经过了认证。对于一些普通的操作，这种可能状态并无大碍，但一旦涉及安全敏感的操作，必须经过认证。Credentials 和 CredentialsMatcherCredentials 是 Subject 的证书，在认证时使用，最常用的就是 password。在通常情况下，为了安全起见，Subject 的 credentials 都需要加密保存，于是 CredentialsMatcher 的作用就体现出来了，见下图：图 4. CredentialsMatcher 的作用这里 CredentialsMatcher 需要将加密后的证书跟用户登录时提供的证书进行比对，完成认证的过程。PAM= Pluggable Authentication Modules在有多个 Realm 的时候使用。由认证策略决定认证结果，即 PAM= Relams + 认证策略。一般的策略有 3 种：AllSuccessful、AtLeastOneSuccessful 和 FirstSuccessful。AuthorizationInfo可以看成是 Role + Permission 的组合体。PermissionResolver 和 Permission它们之间的关系如下：图 5. PermissionResolver 和 Permission 的关系在 Shiro 中，权限被转化为一种字符串描述（字符串分级表示，称之为 WildcardPermission），从而将权限转化为类似于对象 equals 的操作（Shiro 中的 implies 方法）。内置的权限有 2 个：
AllPermission，总是返回 true
WildcardPermission，权限字符串的表示方式。这里重点声明一下。WildcardPermission 是 Shiro 的精妙之处，我们可以将权限表示成字符串，这样对权限的控制可以不拘泥于物理存储，比如对 messagge 类具有修改和删除权限可以标识为：message:update,delete:*，其中‘ * ’表示所有；第一级分隔符为‘ : ’；第二级分隔符为‘ , ’，而对于权限字符串的解释完全可以由应用自己来定。如果要比较权限字符串，可以使用 permission1.implies(permission2)，它分别比较对应位置的字符串，在如下情况中，结果会返回 true：
permission1 中的子串有 * 或 permission1 子串 ==permission2 子串；
permission1 无子串，permission2 有；
permission1 有子串，permission2 无，permission1 的所有子串都是 *。总的说来，Shiro 中的 Permission 需要注意如下内容：
权限的比较实际是字符串的比较，只不过是考虑到了字符串的分级
字符串的分级划分完全由使用者自己决定，Shiro 的惯例是 3 级：资源 : 操作 : 实例。
字符串的使用必须一致，分隔符之间不要有空格，避免无意间引入的不一致。如：定义使用“file : create, update : 1”，而验证使用“file : update”，那么分解之后一个是“ update ”，一个是“ update”，因空格而引起不等。Realm这是一个实际访问安全实体的组件，一般是应用相关的，跟数据源的关系是 1-1。它负责完成认证和鉴权，getAuthenticationInfo 代表了 login 的尝试，鉴权方法则由 Authorizer 继承而来。此处也体现了 Shiro 代码的另一个特点，通过继承来扩充功能。以常用的 JdbcRealm 为例，其继承链如下：图 6. JdbcRealm 的继承链Session它关联一个 Subject 的上下文，其作用类似于在 HttpSession 中保存用户标识，session 一旦过期，则重新登录。Shiro 的 Session 是独立的，其目的是做到环境无关性。为了利用 Web 环境中，Shiro 实现了一个直接使用 HttpSession 的 WebSession。SecurityManager这是一个 Fa?ade 接口，=Authenticator + Authorizer + SessionFactory。在整体框架图中已经看到了它在 Shiro 中所处的位置。其特点同 Realm，一样是使用继承不断地扩充功能。对于 Web 应用一般使用 DefaultWebSecurityManager。Filter在 Web 环境下使用 filter 进行认证和权限检查是毋庸置疑的，而 Shiro 的特点则在于由一个主 Filter 将一群子 filter 串起来：图 7. Filter 的作用在实际使用时，须注意： web.xml 中只需配置 JSecurityFilter。对于 Spring 应用，则使用 SpringJSecurityFilter；子 filter 作为主 filter 的配置参数值出现，特点是：顺序相关
对于多个 URL，验证顺序是由上至下，类似 Exception 的匹配。因此，使用顺序应该是由细到粗。对于同一 URL，子 filter 的验证顺序是从左至右的 AND 操作。
如果配置值中含有分隔符，如 Permission，就需要使用引号来转义。Subjectsubject 代表了一个用户的状态和操作，它提供了所有安全相关的操作，包括认证和签权。可以将其视为另一种形式的 Fa?ade。缺省实现是将这些操作委派给其内部包含的 SecurityManager。Configurationconfiguration 负责将所有这些组件串起来，最终创建 SecurityManager。在 Shiro 中，缺省格式是 ini。整个配置关系如下图：图 8. 配置关系其中：
JSecurityFilter 创建 Configuration 实例，并将 ini 参数值传给 Configuation。在 Spring 环境中，分别使用 SpringJSecurityFilter 和 SpringIniWebConfiguration。
Configuration 实际就是 SecurityManager 的 Factroy，对 SpringIniWebConfiguration 而言，它需要知道 SecurityManager 的 BeanName，该值由 SpringJSecurityFilter 的初始化参数“securityManagerBeanName”值决定。即 SpringJSecurityFilter，实际有两个初始化参数：
config，是 ini 配置文件内容
securityManagerBeanName，是 SecurityManager 的 BeanNameSecurityUtils这是 Shiro 中最重要的工具类，由它可以方便地获得 Subject 和 SecurityManager。杂项
AOP，提供 AOP 方面的支持，实现对某个类某个方法的拦截，从而使权限控制延伸至类的方法。
Cache，提供缓存支持
Codec，提供编码方面的支持
Crypto，提供加密支持
IO，从多个资源位置读写原始数据
JNDI，提供 jndi 支持
util，工具类支持
标签类，用于 Web 页面典型使用对 Shiro 有了一个感官认识后，下面我们就亲自动手试试这个框架吧！下面给大家举了两个使用案例。在开始案例的学习之前，先作好准备工作 -- 获得 Shiro 相关的 jar 包，获取途径有两种：
直接到 J-security 的网站上 ，本文用到的就是这个；
由于 Shiro 目前是 Apache 的孵化项目，还没有发布正式的版本，但是我们可以到 Subversion 上下载代码，之后使用 Maven 构建
mkdir shirocd shirosvn co mvn install之后会得到 shiro-all-1.0-incubating-SNAPSHOT.jar，就可以使用 Shiro 了。示例一：让 Shiro 为你的应用服务这个案例中，我们使用 Grails 向大家讲述 Shiro 的使用。我们要实现如下功能：
用户登录后方可进入系统；
假定一个 message 的安全内容，用户可以创建 message 的内容，但是如果需要修改 / 删除 message 的内容就必须具有相应的权限；
Admin 具有所有的权限；
message 的权限跟角色关联。示例程序执行的流程如下：图 9 程序执行的流程从上图中可以看到，任何人要访问应用中受保护的 URL，首先要通过 Filter 检查用户是否经过认证；对于没有认证的用户会将访问定向到登录页面；对于已经认证的用户，会对用户进行鉴权，这个用户是否具有访问其所提交的 URL 的权限；而管理员可以给角色授权。好了，开始程序的编写啦！创建安全领域类最常见的就是 User、Role 和 Permission，见清单 1。清单 1. User/Role/Permission 的 Domain class class User {
String username
String password
static hasMany= [roles: Role]
static belongsTo= Role
class Role {
String rolename
static hasMany= [users: User, permissions: Permission]
class Permission {
String permission
static hasMany= [roles: Role]
static belongsTo= Role
}这里使用了最简单的情形，即权限传递结构为：Permission -& Role -& User。通常情况下，Permission 也可以分配给单个 User。创建一个安全实体实体名为 message，见清单 2。只有经过授权的用户才能对这个实体进行修改和删除。清单 2. message 的 Domain class class Message {
String details
static constraints = {
}配置 web.xml清单 3. 在 web.xml 加入 SecurityFilter 的内容： &filter&
&filter-name&SecurityFilter&/filter-name&
&filter-class&
org.jsecurity.spring.SpringJSecurityFilter
&/filter-class&
&init-param&
&param-name&securityManagerBeanName&/param-name&
&param-value&jsecSecurityManager&/param-value&
&/init-param&
&filter-mapping&
&filter-name&SecurityFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&这里需要注意：
这个 Filter 应该在 Grails 的 web.xml 中所有缺省的 Filter 最后；
url-pattern 不要使用“/**”，因为这样会造成登录页的 css 和图片无法访问。解决办法，可以通过遵循“只能通过 Controller/Action 访问”这个规则，并使用 Grails 的 Filter 机制，可以保证所有安全 URL 不被非法访问。创建 realm清单 4. conf/spring/resources.groovy beans = {
credentialMatcher(
org.jsecurity.authc.credential.Sha1CredentialsMatcher) {
storedCredentialsHexEncoded = true
permissionResolver(
org.jsecurity.authz.permission.WildcardPermissionResolver)
realm(org.jsecurity.realm.jdbc.JdbcRealm){
permissionResolver = ref("permissionResolver")
dataSource = ref("dataSource")
permissionsLookupEnabled= true
permissionsQuery= "select permission from
permission, role_permissions, role where
permission.id= permission_id and role_id= role.id and rolename= ?"
userRolesQuery= "select rolename from role, role_users, user
where role.id=role_id and user_id= user.id and username=?"
authenticationQuery= "select password from user where username=?"
jsecSecurityManager(
org.jsecurity.web.DefaultWebSecurityManager) {
bean -&bean.destroyMethod = "destroy"
realms = [ ref("realm") ]
}这里使用了 JdbcRealm，同时根据应用情况修改了相应的 SQL。如果允许 Permission 直接分配给 User，即 Permission 和 User 之间是多对多关系，那么 permissionsQuery 应该使用 union，即“role 相关 permission union user 相关 permission”。对于 User 有多个 Role 的情况，JdbcRealm 会循环得出总的结果。安全守护神：SecurityFilters下面就是我们的安全守护神：SecurityFilters，这里遵循 Grails 的 Filter 语法。见清单 5。清单 5. SecurityFilters import org.jsecurity.SecurityUtils
class SecurityFilters {
def filters = {
authc(controller:'*', action:'*', ) {
before = {
if(controllerName!='auth'){
def subject = SecurityUtils.subject
if (!subject.authenticated) {
controller: 'auth',
action: 'login',
targetUri: request.forwardURI - request.contextPath
return false
admin(controller: 'user|role|permission', action: '*'){
before = {
def subject= SecurityUtils.subject
if(!subject.hasRole('admin')){
redirect(controller: 'auth', action: 'unauthorized')
return false
editmessage(controller: 'message', action: 'update|delete'){
before = {
def subject= SecurityUtils.subject
if(!subject.isPermitted(
"${controllerName}:${actionName}:${params.id}")){
redirect(controller: 'auth', action: 'unauthorized')
return false
authc 表示的是所有用户对应用系统的任何访问都要经过 auth 认证，对于没有认证的用户的访问会重定向到登录界面；
admin 表示的是属于 admin 角色的用户对 user/role/permission 具有所有权限，对于非 admin 角色的用户会对其提示没有 user/role/permission 的访问权限；
editmessage 表示当用户对 message 进行修改或者删除的时候对其进行鉴权，只有具有 message 的 update/delete 权限的用户才能对 message 进行修改。在上述代码中还可以看出，我们通常可以由 SecurityUtils 为出发点获得 Subject 和 SecurityManager。需要注意的是，认证的 Filter（authc）要打头阵。认证的代码清单 6. 认证代码 def signIn = {
// 创建 AuthenticationToken
def authToken = new UsernamePasswordToken(
params.username,
params.password)
if (params.rememberMe) {
authToken.rememberMe = true
// 使用 SecurityManager 的 login 登录
this.jsecSecurityManager.login(authToken)
flash.message = message(code: "$params.username")
def targetUri = params.targetUri ?: "/"
log.info "Redirecting to '${targetUri}'."
redirect(uri: targetUri)
catch (AuthenticationException ex){
// 如果出现异常，显示出错信息
log.info "Authentication failure for user '${params.username}'."
flash.message = message(code: "login.failed")
def m = [ username: params.username ]
if (params.rememberMe) {
m['rememberMe'] = true
if (params.targetUri) {
m['targetUri'] = params.targetUri
redirect(action: 'login', params: m)
}授权部分很简单，即对安全实体进行 CRUD。其中 Permission 的权限字符串根据实际情况形成，在本例中：
如果对所有 message 具有修改权限，权限字符串可以为：message:delete,update:*；
如果针对某一个 message 具有修改权限，权限字符串可以为：message:update,delete:messageid。示例二：使用 Shiro Plugin 快速构建安全模块在示例一中，所有的代码都是自己手动写的，这就对初学者要求有些高了。但可喜的是 Grails 社区有了 Shiro 的 plugin，让我们的工作变得非常简单。同样示例一的功能，看看 plugin 能够给我们带来什么样的惊喜？使用步骤如下：
安装 Shiro Plugin，在你的 grails 项目中运行：grails install-plugin shiro，会创建 grails-app/realms 目录，并提供如下新的 Grails 命令：
grails create-auth-controller，创建 AuthController 以及登录窗口，Controller 提供了登录、登出和权限验证失败处理等 Action。grails create-db-realm，创建一个访问数据库的 Realmgrails create-ldap-realm，创建一个访问 ldap 的 Realmgrails create-wildcard-realm，创建一个访问数据库的 Realm，但使用的是 Shiro 的 WildcardPermission。grails quick-start，它是 create-auth-controller 和 create-db-realm 的集合体，是 Shiro 的快速入门，在接下来的内容中将详细介绍它的使用。
下面进行 Shiro 快速入门。在 grails 项目的目录下执行：grails quick-start，这个命令会创建如下内容：
在 grails-app/realms 下创建 ShiroDbRealm，这个 realm 是访问控制的信息库，用来决定一个用户有权访问哪些内容；
在 grails-app/domain 创建 ShiroRole.groovy 和 ShiroUser.groovy；
在 grails-app/controllers 下创建 AuthController，这里提供了登录和退出的 action；
在 grails-app/views 下创建 auth 文件夹以及 login.gsp；
在 grails-app/conf/ 下创建 SecurityFilters.groovy，这里管理着对所有 controller 和 action 的访问控制。
启动程序，当访问 controller 的时候，页面就会重定向到登录页面。但是这个时候是无法登录，因为我们没有添加用户。
进入到 grails-app/conf/ 修改 BootStrap.groovy，
清单 7. 修改后的 BootStrap.groovy def init = { servletContext -&
def user = new User(username: "user",
passwordHash: new Sha1Hash("user").toHex())
user.save()
def role= new Role(name:"admin").addToUsers(user).save()
}重新启动程序，就能使用 user/user 登陆了。
在 plugin 缺省创建的 SecurityFilters 中使用了对所有 URL 进行 before 拦截，但是我们根据实际情况进行修改，例如我们要示例一的 filter 内容，就可以做如下更改：
清单 8. 更改后的 SecurityFilters auth(controller: "*", action: "*"){
accessControl{true}
　　　 management(controller: "user|role|permission", action: "*"){
accessControl{role("admin")}
message(controller: "message", action: "delete|update"){
accessControl{
　　　　　　　
permission("message:${actionName}:${params.id}")
}看到这里，读者可能已经注意到了，这里的代码比示例一中的 Filter 的代码简单的许多。对，Shiro 插件已经将示例一中的类似代码封装到 ShiroGrailsPlugin.groovy 中了，我们使用的时候只需要：调用 accessControl 方法，该方法的参数可以是 Map、Closure 或者 Map+Closure；使用 role( …… )，验证访问对象是否具有相应的角色；使用 permission( …… )，验证访问对象是否具有相应的 Permission。
授权部分内容参见上一示例，这里不做冗述。
Shiro Plugin 中除了为我们提供了上述方便之外，还提供了一些常用的 taglib 来增强用户界面 , 这些 taglib 都在 pluginPath/grails-app/taglib /ShiroTagLib.groovy 中定义，我们可以直接在 gsp 中使用它们。
比如，只有具有修改权限的用户才能够看到一些修改类的按钮显示，可以这样写：清单 9. Taglib 的使用 &shiro:hasPermission permission="message:update,delete"&
&span class="button"&
&g:actionSubmit class="edit" value="Edit" /&
&span class="button"&
&g:actionSubmit class="delete"
onclick="return confirm('Are you sure?');"
value="Delete" /&
&/shiro:hasPermission&如下是经常使用到的 Tag：，输出当前用户的标识
hasRole，判断当前用户是否属于给定的角色，参数：name
hasPermission, 判断当前用户是否具有指定的权限，参数：type，action 或者 permission，判断当前用户是否已经登录
hasAnyRole，判断当前用户是否属于给定的某个角色，参数：in更多的 Tag 请参考 Shiro Plugin 的 gapi 的文档。如果您已经非常了解了 Shiro，可以采用示例一的方式自己写所有的代码，但是对于初学者，作者还建议使用 Shiro plugin，这个插件帮助我们生成了安全相关的基本内容，以及提供了方便的 Tag。总结读到这里，是不是觉得 Shiro 真的不错？！这里给大家举的示例只是抛砖引玉。Shiro 真正的精髓还需要在项目中慢慢的体会。本文是引领我们走向 Shiro 的第一步。在这里要感谢胡键对本文编写的大力支持。源代码中，shiroApp 是示例一的源代码，ShiroPlugin 是示例二的源代码。
下载资源 (shirossc.rar | 2M)相关主题，查看 Grails 与 Shiro 整合的详细情况。，了解 Shiro 的详细情况。，了解 J-security 的详细情况。
添加或订阅评论，请先或。
有新评论时提醒我
static.content.url=http://www.ibm.com/developerworks/js/artrating/SITE_ID=10Zone=Open source, Java technologyArticleID=478167ArticleTitle=将 Shiro 作为应用的权限基础publish-date=