[JavaWeb]SpringSecurity-OAuth2.0 统一认证、资源分离的配置，用于分布式架构、模块化开发的认证体系
前言
关于 OAuth2.0的认证体系，翻阅了好多资料，RCF 文档太多，看了一半就看不下去了，毕竟全英文的文档看起来，是有一点让我烦躁，但也对 OAuth2.0的认证流程有了一个基本的概念，以前用 SpringSecurity 作了一个基于 RBAC 的权限管理系统的基础配置，因此对 SpringSecurity 算是比较了解了，因而 OAuth2.0的实现，也想用 SpringSecurity 的来作，心想应该比较简单，然而...事实上，我反反复复，拿起又放弃，放弃又拿起，来来回回折腾了3个多月，才真正的掌握了这个 OAuth2.0插件（OAuth2.0不是一个独立的框架，只是 SpringSecurity 的一个插件而已）。javascript
官网的 Demo 配置，是基于 JavaConfig 的配置方式，之前都用 XML 的，没接触过 JavaConfig，因此又绕了一圈，把 JavaConfig 方式的全部框架（Spring、SpringMVC、Mybatis、SpringSecurity、Web.xml）基本配置方式都走了一圈， 确实，全代码配置是很酷，很清爽，说实话，从此我也会逐渐往这方面走，由于这个方式比较有代码感，哈哈，可是如今还不行，由于有不少插件啊、特殊的配置方式啊，我都还不清楚要怎么配置，处于安全考虑，仍是老老实实的用 XML 的比较好。css
额外插播一则我团队的招聘广告：html
阿里巴巴 - 淘系技术部招聘：http://www.javashuo.com/article/p-beijdcwl-gr.html前端
项目的说明
网上有不少，SpringSecurityOAuth2.0的配置文章，可是每一个文章，都是将认证服务器和资源服务器写在一块儿的，并无将认证与资源分离，也没有讲不一样的资源之间如何拆分，然而咱们在设计分布式系统的时候，总会以模块化的方式，将不一样的资源写成不一样的项目，好比，将网站的一个电商系统，专门写成一个项目，把网站中的论坛系统，写成另外一个项目，部署的时候，每一个项目就能够单独部署，后端系统均以 RESTFull 的方式开放数据接口（RESTFull就是推荐使用 OAuth2.0的方式进行认证管理）。这样的方式来设计程序，最大的优势就是模块之间相互独立，互不干涉，在开发工做当中，能够并行开发，单独维护，同时模块分离出来，从此还能够进行很便利的集群，而不须要修改任何原来的代码，因此对整个项目的扩展性是很是好的，不一样的项目之间，能够简单的使用 HttpClient 进行通信，OAuth2.0五种受权模式当中，有一种受权模式就是为这种资源服务器之间的通信而设计的。java
认证服务器与资源服务器分离的这个配置方式，同时也实现了“统一认证”的模式，只须要在认真服务器上作了认证，拿到了 Token，就能够访问全部受权的资源服务器。mysql
接下来，咱们开始搭建认证服务器的配置。jquery
POM
项目用到的框架有这几个：Spring、SpringSecurity、Mybatisgit
1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 5 <modelVersion>4.0.0</modelVersion> 6 <groupId>Showings</groupId> 7 <artifactId>OAuthServer</artifactId> 8 <version>1.0-SNAPSHOT</version> 9 <build> 10 <finalName>showings</finalName> 11 <plugins> 12 <!--Mybatis 逆向工程插件--> 13 <plugin> 14 <groupId>org.mybatis.generator</groupId> 15 <artifactId>mybatis-generator-maven-plugin</artifactId> 16 <version>1.3.2</version> 17 <configuration> 18 <verbose>true</verbose> 19 <overwrite>true</overwrite> 20 </configuration> 21 </plugin> 22 <plugin> 23 <groupId>org.apache.maven.plugins</groupId> 24 <artifactId>maven-compiler-plugin</artifactId> 25 <configuration> 26 <source>1.7</source> 27 <target>1.7</target> 28 </configuration> 29 </plugin> 30 </plugins> 31 </build> 32 <properties> 33 <security.version>4.2.2.RELEASE</security.version> 34 <spring.version>4.3.7.RELEASE</spring.version> 35 <security.oauth.version>2.0.7.RELEASE</security.oauth.version> 36 </properties> 37 <dependencies> 38 <!-- SpringFramework Start --> 39 <dependency> 40 <groupId>org.springframework</groupId> 41 <artifactId>spring-core</artifactId> 42 <version>${spring.version}</version> 43 </dependency> 44 45 <dependency> 46 <groupId>org.springframework</groupId> 47 <artifactId>spring-web</artifactId> 48 <version>${spring.version}</version> 49 </dependency> 50 51 <dependency> 52 <groupId>org.springframework</groupId> 53 <artifactId>spring-oxm</artifactId> 54 <version>${spring.version}</version> 55 </dependency> 56 57 <dependency> 58 <groupId>org.springframework</groupId> 59 <artifactId>spring-tx</artifactId> 60 <version>${spring.version}</version> 61 </dependency> 62 63 <dependency> 64 <groupId>org.springframework</groupId> 65 <artifactId>spring-webmvc</artifactId> 66 <version>${spring.version}</version> 67 </dependency> 68 69 <dependency> 70 <groupId>org.springframework</groupId> 71 <artifactId>spring-aop</artifactId> 72 <version>${spring.version}</version> 73 </dependency> 74 75 <dependency> 76 <groupId>org.springframework</groupId> 77 <artifactId>spring-context-support</artifactId> 78 <version>${spring.version}</version> 79 <!--排除自带的日志工具,从而转向使用SLF4J日志--> 80 <exclusions> 81 <exclusion> 82 <groupId>commons-logging</groupId> 83 <artifactId>commons-logging</artifactId> 84 </exclusion> 85 </exclusions> 86 </dependency> 87 88 <dependency> 89 <groupId>org.springframework</groupId> 90 <artifactId>spring-expression</artifactId> 91 <version>${spring.version}</version> 92 </dependency> 93 <!-- SpringFramework End --> 94 <dependency> 95 <groupId>javax.validation</groupId> 96 <artifactId>validation-api</artifactId> 97 <version>2.0.0.Alpha2</version> 98 </dependency> 99 <!--数据有效性验证框架--> 100 <dependency> 101 <groupId>org.hibernate</groupId> 102 <artifactId>hibernate-validator</artifactId> 103 <version>6.0.0.Alpha2</version> 104 </dependency> 105 <!--c3p0--> 106 <dependency> 107 <groupId>com.mchange</groupId> 108 <artifactId>c3p0</artifactId> 109 <version>0.9.5.1</version> 110 </dependency> 111 <!--Mybatis--> 112 <dependency> 113 <groupId>org.mybatis</groupId> 114 <artifactId>mybatis</artifactId> 115 <version>3.3.0</version> 116 </dependency> 117 <!--Mybatis分页工具 pageHelper--> 118 <dependency> 119 <groupId>com.github.pagehelper</groupId> 120 <artifactId>pagehelper</artifactId> 121 <version>4.1.6</version> 122 </dependency> 123 <!--分页搭配SQL解析工具--> 124 <dependency> 125 <groupId>com.github.jsqlparser</groupId> 126 <artifactId>jsqlparser</artifactId> 127 <version>0.9.6</version> 128 </dependency> 129 <!--Mybatis Spring整合--> 130 <dependency> 131 <groupId>org.mybatis</groupId> 132 <artifactId>mybatis-spring</artifactId> 133 <version>1.2.3</version> 134 </dependency> 135 136 <!--MySQL Driver--> 137 <dependency> 138 <groupId>mysql</groupId> 139 <artifactId>mysql-connector-java</artifactId> 140 <version>5.1.6</version> 141 </dependency> 142 <dependency> 143 <groupId>jstl</groupId> 144 <artifactId>jstl</artifactId> 145 <version>1.2</version> 146 </dependency> 147 <!-- https://mvnrepository.com/artifact/javax.el/javax.el-api --> 148 <dependency> 149 <groupId>javax.el</groupId> 150 <artifactId>javax.el-api</artifactId> 151 <version>3.0.1-b04</version> 152 </dependency> 153 154 <!--spring security--> 155 <dependency> 156 <groupId>org.springframework.security</groupId> 157 <artifactId>spring-security-core</artifactId> 158 <version>${security.version}</version> 159 </dependency> 160 <dependency> 161 <groupId>org.springframework.security</groupId> 162 <artifactId>spring-security-web</artifactId> 163 <version>${security.version}</version> 164 </dependency> 165 <dependency> 166 <groupId>org.springframework.security</groupId> 167 <artifactId>spring-security-taglibs</artifactId> 168 <version>${security.version}</version> 169 </dependency> 170 <dependency> 171 <groupId>org.springframework.security</groupId> 172 <artifactId>spring-security-config</artifactId> 173 <version>${security.version}</version> 174 </dependency> 175 176 <dependency> 177 <groupId>org.springframework.security.oauth</groupId> 178 <artifactId>spring-security-oauth2</artifactId> 179 <version>${security.oauth.version}</version> 180 </dependency> 181 182 <!--SLF4J日志 start--> 183 <dependency> 184 <groupId>org.slf4j</groupId> 185 <artifactId>slf4j-api</artifactId> 186 <version>1.7.10</version> 187 </dependency> 188 <dependency> 189 <groupId>ch.qos.logback</groupId> 190 <artifactId>logback-classic</artifactId> 191 <version>1.1.2</version> 192 </dependency> 193 <dependency> 194 <groupId>ch.qos.logback</groupId> 195 <artifactId>logback-core</artifactId> 196 <version>1.1.2</version> 197 </dependency> 198 <!--SLF4J日志 end--> 199 200 <dependency> 201 <groupId>javax.servlet</groupId> 202 <artifactId>javax.servlet-api</artifactId> 203 <version>3.1.0</version> 204 </dependency> 205 206 <!--Jackson start--> 207 <dependency> 208 <groupId>org.codehaus.jackson</groupId> 209 <artifactId>jackson-mapper-asl</artifactId> 210 <version>1.9.13</version> 211 </dependency> 212 <dependency> 213 <groupId>com.fasterxml.jackson.core</groupId> 214 <artifactId>jackson-annotations</artifactId> 215 <version>2.6.1</version> 216 </dependency> 217 <dependency> 218 <groupId>com.fasterxml.jackson.core</groupId> 219 <artifactId>jackson-core</artifactId> 220 <version>2.6.1</version> 221 </dependency> 222 <dependency> 223 <groupId>com.fasterxml.jackson.core</groupId> 224 <artifactId>jackson-databind</artifactId> 225 <version>2.6.1</version> 226 </dependency> 227 <!--Jackson end--> 228 229 </dependencies> 230 231 </project>
Pom 很长，但其实没有多少内容，咱们须要本身写的代码，也很是很是很是的少...= =，是否是很开心？嘿嘿...github
项目目录结构
Yes,你没看错，目录内容真的不多...Java 的部分，真的就没几个= =web
配置文件
首先是 Dao 的配置文件：
application-dao.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 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"> 6 7 8 <!--获取数据库配置文件--> 9 <context:property-placeholder location="classpath:config/db.properties"/> 10 <context:component-scan base-package="cn.com.showings.mapper"/> 11 12 <!--设置数据源c3p0--> 13 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> 14 <property name="driverClass" value="${jdbc.driver}"/> 15 <property name="jdbcUrl" value="${jdbc.url}"/> 16 <property name="user" value="${jdbc.username}"/> 17 <property name="password" value="${jdbc.password}"/> 18 <property name="maxPoolSize" value="50"/> 19 <property name="minPoolSize" value="2"/> 20 <property name="maxIdleTime" value="60"/> 21 </bean> 22 23 <bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean"> 24 <property name="configLocation" value="classpath:config/mybatis-config.xml"/> 25 <property name="dataSource" ref="dataSource"/> 26 <!-- 显式指定Mapper文件位置 --> 27 <property name="mapperLocations"> 28 <list> 29 <value>classpath*:/mapper/*.xml</value> 30 </list> 31 </property> 32 </bean> 33 34 <!--自动扫描mapper接口，并注入sqlsession--> 35 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 36 <property name="basePackage" value="cn.com.showings.mapper"/> 37 <property name="sqlSessionFactoryBeanName" value="sqlSession"/> 38 </bean> 39 40 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> 41 <property name="dataSource" ref="dataSource"/> 42 </bean> 43 </beans>这边能够看到，咱们明明使用的是 Mybatis 的 ORM框架，为啥还要配置一个 jdbcTemplate？其实说来惭愧，本人比较擅长 MyBatis，因此算是强迫症必定要用这个框架，可是人家 Spring 有本身的 SpringData 的框架，而 SpringSecurityOAuth2.0的插件中，不少内容都是用 SpringData 的方式去实现的，我若是要弃用 jdbcTemplate，那我得重写全部框架内涉及的数据库操做，那太累了- -，固然啦，我这么写确定很差，由于认证系统自己没有什么复杂逻辑和除了框架外的额外操做，因此我这么作，挺浪费资源的（占内存），你们能够不要效仿这一块，用到 MyBatis 的地方只有一个读取用户名及密码的接口，也就是说，为了一个接口，确实没有必要引入一个框架。等我掌握了 jdbcTemplate 的用法，我也会去掉这个累赘。
固然~！若是，你的认证系统，跟用户管理系统，是合在一块儿的状况下，那却是没啥问题，毕竟用户管理也是有不少逻辑的，像注册呀、改密啊、绑定密保啊、修改用户信息呀，这些什么鬼的。
接着咱们来配置 Service：
application-service.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" 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"> <!--扫描service--> <context:component-scan base-package="cn.com.showings.service"/> <!--注册统一异常控制--> <bean id="exception" class="cn.com.showings.controller.ExceptionController"/> </beans>没什么内容，看注释就知道了。
而后配置 Transaction：
application-transaction.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" 4 xsi:schemaLocation="http://www.springframework.org/schema/beans 5 http://www.springframework.org/schema/beans/spring-beans.xsd 6 http://www.springframework.org/schema/tx 7 http://www.springframework.org/schema/tx/spring-tx.xsd"> 8 <!--事务管理对象--> 9 <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 10 <property name="dataSource" ref="dataSource"/> 11 </bean> 12 <!--注解事务--> 13 <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/> 14 15 </beans>嗯...事实上，能够不用配置，由于根本用不上。
配置 Spring-mvc：
spring-mvc.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:mvc="http://www.springframework.org/schema/mvc" 6 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"> 7 8 <!--自动扫描控制器--> 9 <context:component-scan base-package="cn.com.showings.controller"/> 10 <!--控制器映射器和控制器适配器--> 11 <mvc:annotation-driven/> 12 <mvc:default-servlet-handler/> 13 14 <mvc:resources mapping="/js/**" location="/js/"/> 15 <mvc:resources mapping="/css/**" location="/css/"/> 16 <mvc:resources mapping="/fonts/**" location="/fonts/"/> 17 18 19 <!--视图渲染--> 20 <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 21 <property name="prefix" value="/WEB-INF/"/> 22 <property name="suffix" value=".jsp"/> 23 </bean> 24 25 <!-- rest json related... start --> 26 <bean id="mappingJacksonHttpMessageConverter" 27 class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> 28 <property name="supportedMediaTypes"> 29 <list> 30 <value>application/json;charset=UTF-8</value> 31 </list> 32 </property> 33 </bean> 34 <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 35 <property name="messageConverters"> 36 <list> 37 <ref bean="mappingJacksonHttpMessageConverter"/> 38 </list> 39 </property> 40 </bean> 41 <!-- rest json related... end --> 42 43 </beans>
这..也没啥可说的，全世界都这么配置的= =
再来配置一个 Mybatis 的分页插件...其实能够不用配置，由于根本用不到，除非之后有啥扩展的话：
mybatis-config.xml
1 <?xml version="1.0" encoding="UTF-8" ?> 2 <!DOCTYPE configuration 3 PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 4 "http://mybatis.org/dtd/mybatis-3-config.dtd"> 5 6 <configuration> 7 <settings> 8 <setting name="logImpl" value="STDOUT_LOGGING"/> 9 </settings> 10 <!-- 11 plugins在配置文件中的位置必须符合要求，不然会报错，顺序以下: 12 properties?, settings?, 13 typeAliases?, typeHandlers?, 14 objectFactory?,objectWrapperFactory?, 15 plugins?, 16 environments?, databaseIdProvider?, mappers? 17 --> 18 <plugins> 19 <!-- com.github.pagehelper为PageHelper类所在包名 --> 20 <plugin interceptor="com.github.pagehelper.PageHelper"> 21 <!-- 4.0.0之后版本能够不设置该参数 --> 22 <property name="dialect" value="mysql"/> 23 <!-- 该参数默认为false --> 24 <!-- 设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用 --> 25 <!-- 和startPage中的pageNum效果同样--> 26 <property name="offsetAsPageNum" value="true"/> 27 <!-- 该参数默认为false --> 28 <!-- 设置为true时，使用RowBounds分页会进行count查询 --> 29 <property name="rowBoundsWithCount" value="true"/> 30 <!-- 设置为true时，若是pageSize=0或者RowBounds.limit = 0就会查询出所有的结果 --> 31 <!-- （至关于没有执行分页查询，可是返回结果仍然是Page类型）--> 32 <property name="pageSizeZero" value="true"/> 33 <!-- 3.3.0版本可用 - 分页参数合理化，默认false禁用 --> 34 <!-- 启用合理化时，若是pageNum<1会查询第一页，若是pageNum>pages会查询最后一页 --> 35 <!-- 禁用合理化时，若是pageNum<1或pageNum>pages会返回空数据 --> 36 <property name="reasonable" value="true"/> 37 <!-- 3.5.0版本可用 - 为了支持startPage(Object params)方法 --> 38 <!-- 增长了一个`params`参数来配置参数映射，用于从Map或ServletRequest中取值 --> 39 <!-- 能够配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置映射的用默认值 --> 40 <!-- 不理解该含义的前提下，不要随便复制该配置 --> 41 <property name="params" value="pageNum=pageHelperStart;pageSize=pageHelperRows;"/> 42 <!-- 支持经过Mapper接口参数来传递分页参数 --> 43 <property name="supportMethodsArguments" value="false"/> 44 <!-- always老是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page --> 45 <property name="returnPageInfo" value="none"/> 46 </plugin> 47 </plugins> 48 </configuration>这个比较详细，由于这个比较麻烦。因此内容都写的不少，若是你不配置这个，天然对目前来讲，也是能够的。
再来一个 LogBack 的配置文件，这个配置文件必须放在配置文件的根目录下，我是使用 IDEA ，maven 的方式搭建项目的，这种配置资源所有都放在 resources 文件夹下，并且文件名字还就得叫这个：
logback.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!-- 3 scan：当此属性设置为true时，配置文件若是发生改变，将会被从新加载，默认值为true。 4 scanPeriod：设置监测配置文件是否有修改的时间间隔，若是没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。 5 debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 6 --> 7 <configuration scan="true" scanPeriod="60 seconds" debug="false"> 8 <!-- 定义日志的根目录 --> 9 10 <property name="LOG_HOME" value="/Users/wuxinzhe/IdeaProjects/OAuthServer/logs"/> 11 <!-- 定义日志文件名称 --> 12 <property name="appName" value="OAuthServer"/> 13 <!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 --> 14 <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"> 15 <Encoding>UTF-8</Encoding> 16 <!-- 17 日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 18 %logger{50} 表示logger名字最长50个字符，不然按照句点分割。 %msg：日志消息，%n是换行符 19 --> 20 <layout class="ch.qos.logback.classic.PatternLayout"> 21 <pattern> 22 %n[%d{yyyy-MM-dd HH:mm:ss}] [userID:%X{userID}] [%logger{50}] %n[%-5level] %msg %n 23 </pattern> 24 </layout> 25 </appender> 26 27 <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其余文件 --> 28 <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender"> 29 <Encoding>UTF-8</Encoding> 30 <!-- 指定日志文件的名称 --> 31 <file>${LOG_HOME}/${appName}.log</file> 32 <!-- 33 当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名 34 TimeBasedRollingPolicy： 最经常使用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。 35 --> 36 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> 37 <!-- 38 滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动 39 %i：当文件大小超过maxFileSize时，按照i进行文件滚动 40 --> 41 <fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern> 42 <!-- 43 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置天天滚动， 44 且maxHistory是365，则只保存最近365天的文件，删除以前的旧文件。注意，删除旧文件是， 45 那些为了归档而建立的目录也会被删除。 46 --> 47 <MaxHistory>365</MaxHistory> 48 <!-- 49 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是没法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy 50 --> 51 <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"> 52 <maxFileSize>100MB</maxFileSize> 53 </timeBasedFileNamingAndTriggeringPolicy> 54 </rollingPolicy> 55 <!-- 56 日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，不然按照句点分割。 %msg：日志消息，%n是换行符 57 --> 58 <layout class="ch.qos.logback.classic.PatternLayout"> 59 <pattern> 60 %n[%d{yyyy-MM-dd HH:mm:ss}] [userID:%X{userID}] [%logger{50}] %n[%-5level] %msg %n 61 </pattern> 62 </layout> 63 </appender> 64 65 <!-- 66 logger主要用于存放日志对象，也能够定义日志类型、级别 67 name：表示匹配的logger类型前缀，也就是包的前半部分 68 level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERROR 69 additivity：做用在于children-logger是否使用 rootLogger配置的appender进行输出，false：表示只用当前logger的appender-ref，true：表示当前logger的appender-ref和rootLogger的appender-ref都有效 70 --> 71 72 <!-- 73 root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应， 74 要么是定义的logger，要么是root，判断的关键在于找到这个logger，而后判断这个logger的appender和level。 75 --> 76 <root level="info"> 77 <appender-ref ref="stdout"/> 78 <appender-ref ref="appLogAppender"/> 79 </root> 80 81 </configuration>这个东西我想是必须的吧，毕竟，日志应该仍是有用的...虽然我整个项目中，都没有输出日志的代码，不过框架仍是有日志输出的需求的。= =
还剩下最后一个配置文件，这个配置文件是 MyBatis 的逆向工程插件的配置文件，若是你有用的话，就弄一个吧
generatorConfig.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <!DOCTYPE generatorConfiguration 3 PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" 4 "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"> 5 6 <generatorConfiguration> 7 <classPathEntry 8 location="/Users/wuxinzhe/.m2/repository/mysql/mysql-connector-java/5.1.6/mysql-connector-java-5.1.6.jar"/> 9 <context id="testTables" targetRuntime="MyBatis3"> 10 <commentGenerator> 11 <!-- 是否去除自动生成的注释 true：是 ： false:否 --> 12 <property name="suppressAllComments" value="true"/> 13 </commentGenerator> 14 <!--数据库链接的信息：驱动类、链接地址、用户名、密码 --> 15 <jdbcConnection driverClass="com.mysql.jdbc.Driver" 16 connectionURL="jdbc:mysql://showings.com.cn:3306/oauth" 17 userId="root" 18 password="199176"> 19 </jdbcConnection> 20 21 <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 22 NUMERIC 类型解析为java.math.BigDecimal --> 23 <javaTypeResolver> 24 <property name="forceBigDecimals" value="false"/> 25 </javaTypeResolver> 26 27 <!-- targetProject:生成PO类的位置 --> 28 <javaModelGenerator targetPackage="cn.com.showings.entity" 29 targetProject="src/main/java"> 30 <!-- enableSubPackages:是否让schema做为包的后缀 --> 31 <property name="enableSubPackages" value="false"/> 32 <!-- 从数据库返回的值被清理先后的空格 --> 33 <property name="trimStrings" value="true"/> 34 </javaModelGenerator> 35 <!-- targetProject:mapper映射文件生成的位置 --> 36 <sqlMapGenerator targetPackage="mapper" 37 targetProject="src/main/resources"> 38 <!-- enableSubPackages:是否让schema做为包的后缀 --> 39 <property name="enableSubPackages" value="false"/> 40 </sqlMapGenerator> 41 <!-- targetPackage：mapper接口生成的位置 --> 42 <javaClientGenerator type="XMLMAPPER" targetPackage="cn.com.showings.mapper" 43 targetProject="src/main/java"> 44 <!-- enableSubPackages:是否让schema做为包的后缀 --> 45 <property name="enableSubPackages" value="false"/> 46 </javaClientGenerator> 47 <!--指定数据库表--> 48 <table tableName="USER_ROLE" 49 enableCountByExample="false" 50 enableUpdateByExample="false" 51 enableDeleteByExample="false" 52 enableSelectByExample="false" 53 selectByExampleQueryId="false"/> 54 </context> 55 </generatorConfiguration>好了，最重要的：
application-security.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:sec="http://www.springframework.org/schema/security" 5 xmlns:oauth2="http://www.springframework.org/schema/security/oauth2" 6 xsi:schemaLocation="http://www.springframework.org/schema/beans 7 http://www.springframework.org/schema/beans/spring-beans.xsd 8 http://www.springframework.org/schema/security 9 http://www.springframework.org/schema/security/spring-security-4.2.xsd 10 http://www.springframework.org/schema/security/oauth2 11 http://www.springframework.org/schema/security/spring-security-oauth2-2.0.xsd"> 12 13 <sec:http pattern="/js/**" security="none"/> 14 <sec:http pattern="/fonts/**" security="none"/> 15 <sec:http pattern="/css/**" security="none"/> 16 17 <!-- /oauth/token 是oauth2登录验证请求的url用于获取access_token ,默认的生存时间是43200秒，即12小时--> 18 <sec:http pattern="/oauth/token" create-session="stateless" authentication-manager-ref="oauth2AuthenticationManager" 19 entry-point-ref="oauth2AuthenticationEntryPoint" use-expressions="false"> 20 <sec:intercept-url pattern="/oauth/token" access="IS_AUTHENTICATED_FULLY"/> 21 <sec:anonymous enabled="false"/> 22 <sec:http-basic entry-point-ref="oauth2AuthenticationEntryPoint"/> 23 <sec:custom-filter ref="clientCredentialsTokenEndpointFilter" before="BASIC_AUTH_FILTER"/> 24 <sec:access-denied-handler ref="oauth2AccessDeniedHandler"/> 25 <sec:csrf disabled="true"/> 26 </sec:http> 27 28 <!--处理访问成功--> 29 <bean id="oauth2AuthenticationEntryPoint" 30 class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint"/> 31 <!--处理访问拒绝--> 32 <bean id="oauth2AccessDeniedHandler" 33 class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler"/> 34 <!--处理认证点--> 35 <bean id="oauthUserApprovalHandler" 36 class="org.springframework.security.oauth2.provider.approval.DefaultUserApprovalHandler"/> 37 <!--处理访问控制--> 38 <bean id="oauth2AccessDecisionManager" class="org.springframework.security.access.vote.UnanimousBased"> 39 <constructor-arg> 40 <list> 41 <bean class="org.springframework.security.oauth2.provider.vote.ScopeVoter"/> 42 <bean class="org.springframework.security.access.vote.RoleVoter"/> 43 <bean class="org.springframework.security.access.vote.AuthenticatedVoter"/> 44 </list> 45 </constructor-arg> 46 </bean> 47 48 <bean id="clientCredentialsTokenEndpointFilter" 49 class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter"> 50 <property name="authenticationManager" ref="oauth2AuthenticationManager"/> 51 </bean> 52 53 <!--可访问客户端参数配置，可转成数据库配置--> 54 <oauth2:client-details-service id="clientDetailsService"> 55 <oauth2:client client-id="web_client" 56 authorized-grant-types="password,authorization_code,refresh_token,implicit" 57 secret="web" scope="read,write"/> 58 </oauth2:client-details-service> 59 60 <!--可访问客户端参数配置，数据库管理方案--> 61 <!--<bean id="clientDetailsService"--> 62 <!--class="org.springframework.security.oauth2.provider.client.JdbcClientDetailsService">--> 63 <!--<constructor-arg index="0" ref="dataSource"/>--> 64 <!--</bean>--> 65 66 <bean id="oauth2ClientDetailsUserService" 67 class="org.springframework.security.oauth2.provider.client.ClientDetailsUserDetailsService"> 68 <constructor-arg ref="clientDetailsService"/> 69 </bean> 70 71 <sec:authentication-manager id="oauth2AuthenticationManager"> 72 <sec:authentication-provider user-service-ref="oauth2ClientDetailsUserService"/> 73 </sec:authentication-manager> 74 75 <!--Config token services--> 76 <bean id="tokenStore" class="org.springframework.security.oauth2.provider.token.store.JdbcTokenStore"> 77 <constructor-arg index="0" ref="dataSource"/> 78 </bean> 79 80 <bean id="tokenServices" class="org.springframework.security.oauth2.provider.token.DefaultTokenServices"> 81 <property name="tokenStore" ref="tokenStore"/> 82 <property name="clientDetailsService" ref="clientDetailsService"/> 83 <property name="supportRefreshToken" value="true"/> 84 </bean> 85 <bean id="jdbcAuthorizationCodeServices" 86 class="org.springframework.security.oauth2.provider.code.JdbcAuthorizationCodeServices"> 87 <constructor-arg index="0" ref="dataSource"/> 88 </bean> 89 <!--oauth2 的server所能支持的请求类型--> 90 <oauth2:authorization-server client-details-service-ref="clientDetailsService" token-services-ref="tokenServices" 91 user-approval-handler-ref="oauthUserApprovalHandler" 92 user-approval-page="oauth_approval" 93 error-page="oauth_error"> 94 <oauth2:authorization-code authorization-code-services-ref="jdbcAuthorizationCodeServices"/> 95 <oauth2:implicit/> 96 <oauth2:refresh-token/> 97 <oauth2:client-credentials/> 98 <oauth2:password/> 99 </oauth2:authorization-server> 100 101 <oauth2:resource-server id="webResourceServer" resource-id="web-resource" token-services-ref="tokenServices"/> 102 103 <sec:http disable-url-rewriting="true" use-expressions="false" authentication-manager-ref="authenticationManager"> 104 <sec:intercept-url pattern="/oauth/**" access="ROLE_USER"/> 105 <sec:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY"/> 106 <sec:form-login authentication-failure-url="login.html?authorization_error=true" 107 default-target-url="index.html" 108 login-page="login.html" login-processing-url="login"/> 109 <sec:logout logout-success-url="success.html" logout-url="logout"/> 110 <sec:access-denied-handler error-page="login.html?access_denied=true"/> 111 <sec:anonymous/> 112 <sec:csrf disabled="true"/> 113 </sec:http> 114 115 <!-- 验证的权限控制 --> 116 <sec:authentication-manager id="authenticationManager"> 117 <sec:authentication-provider user-service-ref="userServiceImpl"> 118 <sec:password-encoder hash="md5"/> 119 </sec:authentication-provider> 120 </sec:authentication-manager> 121 122 </beans>这个文档很长，并且我也必须作一个讲解，不然就算配置了，估计也不知道怎么用。
咱们，分段讲解：
1 <sec:http pattern="/js/**" security="none"/> 2 <sec:http pattern="/fonts/**" security="none"/> 3 <sec:http pattern="/css/**" security="none"/>这个，是告诉框架，这三块内容，不须要权限验证，任何人均可以获取，因此对这三个资源，直接绕过 SpringSecurity 框架。
1 <!-- /oauth/token 是oauth2登录验证请求的url用于获取access_token ,默认的生存时间是43200秒，即12小时--> 2 <sec:http pattern="/oauth/token" create-session="stateless" authentication-manager-ref="oauth2AuthenticationManager" 3 entry-point-ref="oauth2AuthenticationEntryPoint" use-expressions="false"> 4 <sec:intercept-url pattern="/oauth/token" access="IS_AUTHENTICATED_FULLY"/> 5 <sec:anonymous enabled="false"/> 6 <sec:http-basic entry-point-ref="oauth2AuthenticationEntryPoint"/> 7 <sec:custom-filter ref="clientCredentialsTokenEndpointFilter" before="BASIC_AUTH_FILTER"/> 8 <sec:access-denied-handler ref="oauth2AccessDeniedHandler"/> 9 <sec:csrf disabled="true"/> 10 </sec:http>
这部分，是OAuth2.0用于获取 token 的地址，就是上面写的"/oauth/token"，上面的配置内容我挑着讲解一下，首先是 “authentication-manager-ref”，这是是认证管理器的指定，意思就是，当访问这个资源的时候，咱们要用特定的，专门为获取 token 的认证管理器，这么说可能不理解，那有特定的认证管理器，就确定有普通的认证管理器，普通的认证管理器，就是以前我配置 RBAC 权限系统的时候，用户的以用户名及密码登陆时的那个验证用户密码的管理器，这个是最普通的，也是必须有的管理器，相对这个管理器来讲，OAuth2.0须要一个专门对“/oauth/token”这个资源（要获取的 token 自己就是一种资源），有一个认证管理器，认证的是 client-id 与对应的 client-secret，就是对访问客户端的认证，咱们对客户端程序是有限制的，不是每一个客户端程序都可以访问咱们的接口，而是咱们资源服务器受权的某个客户端才能有资格来申请，这么说可能仍是不太好理解，我用现实中的例子来讲明这个问题：
咱们都在某些小型的网站，尤为是论坛上看到登陆时，能够选择使用 QQ 登陆，对吧？这也是 OAuth2.0的一个业务场景，其实这些小型网站要实现这类功能以前，必须先跟腾讯申请合做，而后腾讯会在它本身的客户端数据表中，建立一个属于这个小网站的一个 ID，对于腾讯来讲，这个小网站就是一个客户端，他想要获取腾讯的一些资源，好比用户昵称及头像。那小网站 A 跟腾讯签定了合做协议，腾讯赞成它做为一个客户端来访问资源（仅仅是说 token 的资源，由于这个针对客户端的受权认证，仅仅只是用来申请 token 的），可是腾讯不容许没有跟他签定合做的其余小网站来访问资源，因此那些没有申请合做的小网站，没有腾讯分发的 ID及密码，天然就不能发起访问申请。并且，OAuth2.0有一个很重要的功能，就是根据不一样的客户端，能够区别对待，好比一个比较大一点的中型网站，跟腾讯有付费关系，就是所谓的哈哈，QQ 会员级别，那他跟其余没付费的小网站天然不一样，腾讯能让她访问的资源内容的范围确定也不一样，因此经过不一样的 client，天然就能够进行区别对待，堂而皇之收取 QQ 会员费啦~！哈哈
其余元素，我就不解释了，都有对应的 Bean，对应 Bean 上都有注释，主要是没啥很差理解的，因此就不须要解释了吧。
<!--可访问客户端参数配置，可转成数据库配置--> <oauth2:client-details-service id="clientDetailsService"> <oauth2:client client-id="web_client" authorized-grant-types="password,authorization_code,refresh_token,implicit" secret="web" scope="read,write"/> </oauth2:client-details-service>这就是刚才我说的，客户端配置，我这边是彻底是写死的，由于个人网站没打算创建开放平台给别人，妈蛋，个人网站要有那个能力，你们都来我这里获取资源，我还在这里写代码做死？固然啦，我在底下有注释，用于数据库配置的方式，其实也没啥难的。这边咱们能够看一下，authorized-grant-type 是认证类型，五种认证类型，能够根据须要，作一些取舍，通常，经常使用的是 authorization_code，这个是最经常使用的手法，资源服务器之间的通信可使用implicit，具体这几种方式怎么用，恩，回头我再写一个博客专门讲好了。
1 <!--oauth2 的server所能支持的请求类型--> 2 <oauth2:authorization-server client-details-service-ref="clientDetailsService" token-services-ref="tokenServices" 3 user-approval-handler-ref="oauthUserApprovalHandler" 4 user-approval-page="oauth_approval" 5 error-page="oauth_error"> 6 <oauth2:authorization-code authorization-code-services-ref="jdbcAuthorizationCodeServices"/> 7 <oauth2:implicit/> 8 <oauth2:refresh-token/> 9 <oauth2:client-credentials/> 10 <oauth2:password/> 11 </oauth2:authorization-server>这个呢，能够讲得也很少，就是那个 user-approval-page，我讲一下，咱们在使用微信的时候，其实微信也是用的 OAuth2.0，只是没有让你输入用户密码，由于你自己就登陆着微信，而微信是 Socket 链接，是收信任的连接方式，因此当你点一些小程序或者一些其余基于微信开发的一些程序的时候，就历来不用输入用户密码，可是必定会有一个提示，就是问你是否要受权微信登陆，其实就是这样的一个相似的受权页面，如图：
为啥要有这个页面，好像画蛇添足的感受呢？很简单咯，以防万一，一些恶意网站，在你不知情的状况下，去调用你的信息。而 error-page 就是当用户点击拒绝访问的时候，跳转的页面。
1 <oauth2:resource-server id="webResourceServer" resource-id="web-resource" token-services-ref="tokenServices"/>这个是资源 ID，定义资源服务器的，恩...其实我也不知道这个要不要加入到这里，没试过，由于这个是必需要加到资源服务器的配置文件当中的，而认证服务器要不要我还不清楚，由于我目前尚未把资源服务器的内容写起来，反正暂且先写着，若是不须要，回头再去掉就行。
1 <sec:http disable-url-rewriting="true" use-expressions="false" authentication-manager-ref="authenticationManager"> 2 <sec:intercept-url pattern="/oauth/**" access="ROLE_USER"/> 3 <sec:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY"/> 4 <sec:form-login authentication-failure-url="login.html?authorization_error=true" 5 default-target-url="index.html" 6 login-page="login.html" login-processing-url="login"/> 7 <sec:logout logout-success-url="success.html" logout-url="logout"/> 8 <sec:access-denied-handler error-page="login.html?access_denied=true"/> 9 <sec:anonymous/> 10 <sec:csrf disabled="true"/> 11 </sec:http> 12 13 <!-- 验证的权限控制 --> 14 <sec:authentication-manager id="authenticationManager"> 15 <sec:authentication-provider user-service-ref="userServiceImpl"> 16 <sec:password-encoder hash="md5"/> 17 </sec:authentication-provider> 18 </sec:authentication-manager>
这个，就是用户认证系统，无论用RBAC权限管理设计，仍是 OAuth2.0协议，都不可避免要输入用户密码，这部分呢就是用来定义这个的。这里有一个坑啊，就是这两个东西，必须放在最后面，由于，咱们的拦截地址是拦截/**及/oauth/**，若是写在刚才申请 token 的那个/oauth/token 的配置前面，则会被覆盖，那无论怎么输入用户密码，都不会走用户验证管理器，而是都去走刚才上面说到的那个特殊的，验证client的用户验证管理器。那就无论怎样，都登陆不了了= =。
好了，最后就是 Web.xml的配置了。
web.xml
1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 5 version="3.1"> 6 <!--设置spring 配置文件的位置--> 7 <context-param> 8 <param-name>contextConfigLocation</param-name> 9 <param-value>classpath*:config/application-*.xml</param-value> 10 </context-param> 11 <context-param> 12 <param-name>webAppRootKey</param-name> 13 <param-value>web.root</param-value> 14 </context-param> 15 <listener> 16 <listener-class>org.springframework.web.util.WebAppRootListener</listener-class> 17 </listener> 18 <!--配置spring listener--> 19 <listener> 20 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 21 </listener> 22 <!--解决POST乱码问题--> 23 <filter> 24 <filter-name>CharacterEncodingFilter</filter-name> 25 <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> 26 <init-param> 27 <param-name>encoding</param-name> 28 <param-value>utf-8</param-value> 29 </init-param> 30 </filter> 31 <filter-mapping> 32 <filter-name>CharacterEncodingFilter</filter-name> 33 <url-pattern>/*</url-pattern> 34 </filter-mapping> 35 <filter> 36 <filter-name>springSecurityFilterChain</filter-name> 37 <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> 38 </filter> 39 <filter-mapping> 40 <filter-name>springSecurityFilterChain</filter-name> 41 <url-pattern>/*</url-pattern> 42 </filter-mapping> 43 <!--springMVC前端控制器配置--> 44 <servlet> 45 <servlet-name>dispatcherServlet</servlet-name> 46 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 47 <init-param> 48 <param-name>contextConfigLocation</param-name> 49 <param-value>classpath*:config/spring-mvc.xml</param-value> 50 </init-param> 51 <load-on-startup>2</load-on-startup> 52 </servlet> 53 <servlet-mapping> 54 <servlet-name>dispatcherServlet</servlet-name> 55 <url-pattern>/</url-pattern> 56 </servlet-mapping> 57 <welcome-file-list> 58 <welcome-file>login.html</welcome-file> 59 </welcome-file-list> 60 </web-app>
这个配置很普通，没有什么复杂的。恩，关键的地方说一下，就是 welcome-file-list 这边，我设置成了 login.html，我是这么考虑的：这个认证系统吧，若是真的用起来，可能会比较频繁，因此不但愿老是要通过 spirng 及 spring-mvc 来控制，就作成静态页面好了，这样能够提升些效率。并且自己登陆也没有什么复杂逻辑，用不到 JSP，因此我把登陆页面作成了静态页面，并且但愿项目的默认访问地址，就是登陆页面，由于自己这就只是一个认证系统而已，没有其余的功能。
可是看一下前面的 Security 配置中，对用户登陆认证的部分的配置，我配置了登陆失败的一些错误页面，
<sec:form-login authentication-failure-url="login.html?authorization_error=true" default-target-url="index.html" login-page="login.html" login-processing-url="login"/> <sec:access-denied-handler error-page="login.html?access_denied=true"/>
首先是“login.html?authorization_error=true”，这个是当认证失败，就是验证用户密码错误的时候，返回的页面，固然仍是要回到登陆页面，可是带了URL参数，还有一个就是“login.html?access_denied=true”，这个是访问拒绝的页面，就是当你没有登陆就想要访问一些资源的时候，会跳转到这个页面，其实仍是登陆页面，只是携带参数不一样，不过...自己认证系统就没有什么其余接口，因此这个可能也没啥用就是了...那反正定义一个，也好。
在 login.html 页面呢，由于是静态的，不能用 jstl 表达式来获取 URL 参数从而显示不一样的提示语，可是可使用 js 来作这个事儿，回头我再贴出 login.html 的代码。
几个页面
login.html
<!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8"> <title>登陆验证</title> </head> <link rel="stylesheet" href="css/bootstrap.min.css"> <script type="text/javascript" src="js/jquery-3.2.1.min.js"></script> <script type="text/javascript" src="js/bootstrap.min.js"></script> <body> <div class="container"> <div class="row" style="height: 150px"></div> <div class="row"> <div class="col-xs-4"></div> <div class="col-xs-4"> <div class="page-header"> <h1 class="text-center">系统登陆</h1> </div> <form action="/login" method="post"> <div class="form-group"> <div class="input-group"> <span class="input-group-addon"> <span class="glyphicon glyphicon-user"></span> </span> <input type="text" class="form-control" placeholder="用户名" name="username" aria-describedby="basic-addon1"> </div> </div> <div class="form-group"> <div class="input-group"> <span class="input-group-addon"><span class="glyphicon glyphicon-lock"></span></span> <input type="password" class="form-control" placeholder="密码" name="password" aria-describedby="basic-addon1"> </div> </div> <button type="submit" class="btn btn-default pull-right">登陆</button> </form> </div> <div class="col-xs-4"></div> </div> <div class="row" style="height: 10px"> </div> <div class="row"> <div class="col-xs-4"></div> <div class="col-xs-4"> <div id="tip" class="alert alert-danger alert-dismissible hidden" role="alert"> <button type="button" class="close" data-dismiss="alert" aria-label="Close"> <span aria-hidden="true">×</span> </button> <strong>提示!</strong> <span id="tip-message"></span> </div> </div> <div class="col-xs-4"></div> </div> </div> </body> <script type="text/javascript"> function getQueryString(name) { var reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i'); var r = window.location.search.substr(1).match(reg); if (r !== null) { return unescape(r[2]); } return null; } if (getQueryString('authorization_error') !== null) { $('#tip-message').text('用户密码不正确！'); $('#tip').removeClass('hidden'); } else if (getQueryString('access_denied') !== null) { $('#tip-message').text('您还还没有登陆！'); $('#tip').removeClass('hidden'); } else { $('#tip').addClass('hidden'); } </script> </html>oauth_approval.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <!DOCTYPE HTML> <html> <head> <title>Oauth Approval</title> <link rel="stylesheet" href="../css/bootstrap.min.css"> <script type="text/javascript" src="../js/jquery-3.2.1.min.js"></script> <script type="text/javascript" src="../js/bootstrap.min.js"></script> </head> <body> <div class="container"> <div class="row"> <div class="col-xs-12"> <div class="page-header"> <h1 class="text-center">你是否受权"${authorizationRequest.clientId}"访问你的我的信息？</h1> </div> </div> </div> <div class="row"> <div class="col-xs-4"></div> <div class="col-xs-4"> <form id="oauth-form" action="${pageContext.request.contextPath}/oauth/authorize" method="post"> <input id="approval" name='user_oauth_approval' type='hidden'/> <div class="btn-group btn-group-justified"> <div class="btn-group" role="group"> <button id="access_authorize" class="btn btn-lg btn-primary" type="button">赞成受权</button> </div> <div class="btn-group" role="group"> <button id="access_denied" class="btn btn-lg btn-danger" type="button">拒绝访问</button> </div> </div> </form> </div> <div class="col-xs-4"></div> </div> </div> <script type="text/javascript"> var approval = $('#approval'); $('#access_authorize').on('click', function () { approval.val('true'); $('#oauth-form').submit(); }); $('#access_denied').on('click', function () { approval.val('false'); $('#oauth-form').submit(); }); </script> </body> </html>oauth_error.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <!DOCTYPE HTML> <html> <head> <title>受权失败</title> </head> <body> <h3> 受权失败！ </h3> <div class="alert alert-danger"> <c:out value="${error.summary}"/> </div> </body> </html>
几个类
ExceptionController.java
这个是统一异常处理,这边针对非 Ajax 请求，返回 error 页面，可是我没有写 Error 页面，懒得写啦，由于根本用不到，可是该补仍是得补上，之后再补好了。这个我就说明一下，省得有朋友看不懂这块。
package cn.com.showings.controller; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.HttpStatus; import org.springframework.util.StringUtils; import org.springframework.web.servlet.HandlerExceptionResolver; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.view.json.MappingJackson2JsonView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /** * 知识产权声明:本文件自建立起,其内容的知识产权即归属于原做者,任何他人不可擅自复制或模仿. * 建立者: wu 建立时间: 16/9/29 * 类说明: 统一异常处理 */ public class ExceptionController implements HandlerExceptionResolver { private static Logger logger = LoggerFactory.getLogger(ExceptionController.class); public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception ex) { logger.error(ex.getMessage(), ex); ModelAndView modelAndView = new ModelAndView(); if (isAjaxRequest(httpServletRequest)) { modelAndView.setView(new MappingJackson2JsonView()); } else { modelAndView.setViewName("error"); } modelAndView.setStatus(HttpStatus.INTERNAL_SERVER_ERROR); modelAndView.addObject("error_info", ex.getMessage()); return modelAndView; } private boolean isAjaxRequest(HttpServletRequest request) { return "XMLHttpRequest".equals(request.getHeader("X-Requested-With")) || !StringUtils.isEmpty(request.getParameter("jsonp")); } }UserServiceImpl.java
这个类是实现了 UserService 接口，而 UserService 接口内没有任何内容，只是为了留给之后万一要集成用户管理系统或者其余用户操做，故意加的一层接口。UserService 接口继承了 SpringSecurity 框架中的 UserDetailsService，因此这个类目前只实现了一个方法，就是惟一须要使用 mybatis 读取数据库的接口= =。。若是后期不打算扩展其余功能，单纯就只用来认证，那可去掉 Mybatis，直接jdbcTemplate 来查询用户信息。
package cn.com.showings.service.impl; import cn.com.showings.entity.MyUserDetail; import cn.com.showings.entity.User; import cn.com.showings.mapper.UserMapper; import cn.com.showings.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; /** * 类说明：用户服务，管理用户注册、读取用户信息等用户相关操做 */ @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { User user = userMapper.selectByUsername(username); if (user == null) { throw new UsernameNotFoundException("Not found any user for username[" + username + "]"); } else { return new MyUserDetail(user); } } }MyUserDetail.java
这个类，是用来实现框架中的 UserDetails 接口的,框架中没有什么实体类这种概念，都是用接口实现的，咱们这边就主要按照标准，组装一下这个对象的数据结构。
package cn.com.showings.entity; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.UserDetails; import java.util.ArrayList; import java.util.Collection; import java.util.List; /** * 类说明：实现 UserDetail */ public class MyUserDetail implements UserDetails { private static final long serialVersionUID = 3006176344390176165L; private User user; private static final String ROLE_PREFIX = "ROLE_"; private List<GrantedAuthority> grantedAuthorities = new ArrayList<>(); public MyUserDetail(User user) { this.user = user; initAuthority(); } private void initAuthority() { List<Role> roleList = user.getRoleList(); for (Role role : roleList) { this.grantedAuthorities.add(new SimpleGrantedAuthority(ROLE_PREFIX + role.getName())); } } public Collection<? extends GrantedAuthority> getAuthorities() { return this.grantedAuthorities; } public String getPassword() { return this.user.getPassword(); } public String getUsername() { return this.user.getUsername(); } public boolean isAccountNonExpired() { return true; } public boolean isAccountNonLocked() { return true; } public boolean isCredentialsNonExpired() { return true; } public boolean isEnabled() { return true; } public User getUser() { return user; } }剩下就是 User 类和 Role 类，以及根据数据库多对多映射出来的 UserRole 类，都是实体类，没啥好说的，无非就是根据数据库映射出来的几个字段而已。
OK 啦，认证服务器的配置就配置完了。资源服务器呢，其实没有啥特别的，除了 SpringSecurity 的那个配置文件，其余都跟受权服务器同样，固然资源服务器要扩展一些本身的功能，确定还有一些特殊的东西，那反正就权限认证这块，我贴出代码，其余的配置，大家均可以按照受权服务器来配置，配置一些好比 dao，spirng，mvc，logback，mybatis，因此,上面那些其实也不是没用的啦= =
好了，区别就在于 security 的配置：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:sec="http://www.springframework.org/schema/security" 5 xmlns:oauth2="http://www.springframework.org/schema/security/oauth2" 6 xsi:schemaLocation="http://www.springframework.org/schema/beans 7 http://www.springframework.org/schema/beans/spring-beans.xsd 8 http://www.springframework.org/schema/security 9 http://www.springframework.org/schema/security/spring-security-4.2.xsd 10 http://www.springframework.org/schema/security/oauth2 11 http://www.springframework.org/schema/security/spring-security-oauth2-2.0.xsd"> 12 13 <sec:http pattern="/**" create-session="never" entry-point-ref="oauth2AuthenticationEntryPoint" 14 access-decision-manager-ref="oauth2AccessDecisionManager" use-expressions="false"> 15 <sec:anonymous enabled="false"/> 16 <sec:intercept-url pattern="/**" access="ROLE_USER,SCOPE_READ"/> 17 <sec:custom-filter ref="webResourceServer" before="PRE_AUTH_FILTER"/> 18 <sec:access-denied-handler ref="oauth2AccessDeniedHandler"/> 19 <sec:csrf disabled="true"/> 20 </sec:http> 21 22 <!--处理访问成功--> 23 <bean id="oauth2AuthenticationEntryPoint" 24 class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint"/> 25 <!--处理访问拒绝--> 26 <bean id="oauth2AccessDeniedHandler" 27 class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler"/> 28 <!--处理认证点--> 29 <bean id="oauthUserApprovalHandler" 30 class="org.springframework.security.oauth2.provider.approval.DefaultUserApprovalHandler"/> 31 <!--处理访问控制--> 32 <bean id="oauth2AccessDecisionManager" class="org.springframework.security.access.vote.UnanimousBased"> 33 <constructor-arg> 34 <list> 35 <bean class="org.springframework.security.oauth2.provider.vote.ScopeVoter"/> 36 <bean class="org.springframework.security.access.vote.RoleVoter"/> 37 <bean class="org.springframework.security.access.vote.AuthenticatedVoter"/> 38 </list> 39 </constructor-arg> 40 </bean> 41 42 43 <bean id="tokenStore" class="org.springframework.security.oauth2.provider.token.store.JdbcTokenStore"> 44 <constructor-arg index="0" ref="dataSource"/> 45 </bean> 46 47 <bean id="tokenServices" class="org.springframework.security.oauth2.provider.token.DefaultTokenServices"> 48 <property name="tokenStore" ref="tokenStore"/> 49 <property name="supportRefreshToken" value="true"/> 50 </bean> 51 52 <oauth2:resource-server id="webResourceServer" resource-id="web-resource" token-services-ref="tokenServices"/> 53 54 55 </beans>
这边的 DataSource要说明一下，这个链接的数据库跟认证服务器的数据库要是同样的，因此这个项目若是数据库分库的话，天然要有多个 dataSource，建议也是分开，认证系统不要跟业务系统混在一块儿，从根本上区分开每一个模块，数据库也要分开。而这个 dataSource 由于连接的跟认证系统是相同的数据库，因此天然就是一个统一认证的模式，只要在认证系统内认证过的，获取的 token 在其余模块中也会到相同的数据库中去验证。另外说一下，这个资源服务器的配置内容，有一点乱，可能还能够继续精简一些，资源服务器我尚未深刻去看，可能这也已是最小配置了。
对了，数据库不能忘了。
1 /* 2 Navicat Premium Data Transfer 3 4 Source Server : Showings 5 Source Server Type : MySQL 6 Source Server Version : 50554 7 Source Host : 120.25.99.8 8 Source Database : oauth 9 10 Target Server Type : MySQL 11 Target Server Version : 50554 12 File Encoding : utf-8 13 14 Date: 04/21/2017 09:08:54 AM 15 */ 16 17 SET NAMES utf8; 18 SET FOREIGN_KEY_CHECKS = 0; 19 20 -- ---------------------------- 21 -- Table structure for `oauth_access_token` 22 -- ---------------------------- 23 DROP TABLE IF EXISTS `oauth_access_token`; 24 CREATE TABLE `oauth_access_token` ( 25 `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, 26 `token_id` varchar(255) DEFAULT NULL, 27 `token` blob, 28 `authentication_id` varchar(255) DEFAULT NULL, 29 `user_name` varchar(255) DEFAULT NULL, 30 `client_id` varchar(255) DEFAULT NULL, 31 `authentication` blob, 32 `refresh_token` varchar(255) DEFAULT NULL, 33 KEY `token_id_index` (`token_id`), 34 KEY `authentication_id_index` (`authentication_id`), 35 KEY `user_name_index` (`user_name`), 36 KEY `client_id_index` (`client_id`), 37 KEY `refresh_token_index` (`refresh_token`) 38 ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 39 40 -- ---------------------------- 41 -- Table structure for `oauth_client_details` 42 -- ---------------------------- 43 DROP TABLE IF EXISTS `oauth_client_details`; 44 CREATE TABLE `oauth_client_details` ( 45 `client_id` varchar(255) NOT NULL, 46 `resource_ids` varchar(255) DEFAULT NULL, 47 `client_secret` varchar(255) DEFAULT NULL, 48 `scope` varchar(255) DEFAULT NULL, 49 `authorized_grant_types` varchar(255) DEFAULT NULL, 50 `web_server_redirect_uri` varchar(255) DEFAULT NULL, 51 `authorities` varchar(255) DEFAULT NULL, 52 `access_token_validity` int(11) DEFAULT NULL, 53 `refresh_token_validity` int(11) DEFAULT NULL, 54 `additional_information` text, 55 `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, 56 `archived` tinyint(1) DEFAULT '0', 57 `trusted` tinyint(1) DEFAULT '0', 58 `autoapprove` varchar(255) DEFAULT 'false', 59 PRIMARY KEY (`client_id`) 60 ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 61 62 -- ---------------------------- 63 -- Table structure for `oauth_code` 64 -- ---------------------------- 65 DROP TABLE IF EXISTS `oauth_code`; 66 CREATE TABLE `oauth_code` ( 67 `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, 68 `code` varchar(255) DEFAULT NULL, 69 `authentication` blob, 70 KEY `code_index` (`code`) 71 ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 72 73 -- ---------------------------- 74 -- Table structure for `oauth_refresh_token` 75 -- ---------------------------- 76 DROP TABLE IF EXISTS `oauth_refresh_token`; 77 CREATE TABLE `oauth_refresh_token` ( 78 `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, 79 `token_id` varchar(255) DEFAULT NULL, 80 `token` blob, 81 `authentication` blob, 82 KEY `token_id_index` (`token_id`) 83 ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 84 85 -- ---------------------------- 86 -- Table structure for `ROLE` 87 -- ---------------------------- 88 DROP TABLE IF EXISTS `ROLE`; 89 CREATE TABLE `ROLE` ( 90 `ID` int(2) NOT NULL AUTO_INCREMENT, 91 `NAME` varchar(10) NOT NULL, 92 PRIMARY KEY (`ID`) 93 ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; 94 95 -- ---------------------------- 96 -- Table structure for `USER` 97 -- ---------------------------- 98 DROP TABLE IF EXISTS `USER`; 99 CREATE TABLE `USER` ( 100 `UID` varchar(255) NOT NULL, 101 `CREATE_TIME` datetime DEFAULT NULL, 102 `PASSWORD` varchar(255) NOT NULL, 103 `USERNAME` varchar(255) NOT NULL, 104 `LAST_LOGIN_TIME` datetime DEFAULT NULL, 105 PRIMARY KEY (`UID`), 106 UNIQUE KEY `guid` (`UID`), 107 UNIQUE KEY `username` (`USERNAME`) 108 ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 109 110 -- ---------------------------- 111 -- Table structure for `USER_ROLE` 112 -- ---------------------------- 113 DROP TABLE IF EXISTS `USER_ROLE`; 114 CREATE TABLE `USER_ROLE` ( 115 `ID` int(255) NOT NULL AUTO_INCREMENT, 116 `USER_UID` varchar(256) NOT NULL, 117 `ROLE_ID` int(1) NOT NULL, 118 PRIMARY KEY (`ID`), 119 KEY `user_id_index` (`USER_UID`(255)) 120 ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8; 121 122 SET FOREIGN_KEY_CHECKS = 1;
这个。补充说一下，用户密码要通过 MD5加密，验证的时候，也是有加密，因此存入数据库的时候，要是没有加密就会验证不经过。
下一篇，我会写这个怎么用，固然有的朋友熟悉的，天然也知道这个怎么用。
相关文章
- 1. 构建基于分布式SOA架构的统一身份认证体系
- 2. 分布式系统认证方案
- 3. 一种全新的分布式用户认证架构设计
- 4. Laravel认证模块开发
- 5. 分布式认证方案
- 6. Django的认证系统 -- auth模块
- 7. Django的认证系统—auth模块
- 8. Django的认证系统 auth模块
- 9. 在Keystone V3基础上改进的分布式认证体系
- 10. 分布式服务架构下的身份认证
- 更多相关文章...
- • IP地址分配（静态分配+动态分配+零配置） - TCP/IP教程
- • 互联网系统应用架构基础分析 - 红包项目实战
- • 常用的分布式事务解决方案
- • Docker容器实战(七) - 容器眼光下的文件系统
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章