深入boot2.0 12章 spring security

今天药忘吃喽~ 2023-02-19 14:27 11阅读 0赞

我的整理：
    spring security 安全访问控制
    认证：authentication    n. 证明；鉴定；证实
    授权：authorization      n. 授权，认可；批准，委任
    请求 需要认证身份 才可以访问
    groupId：org.springframework.boot
    artifactId:spring-boot-starter-security
    @EnableWebSecurity 默认打开
    基于servlet 过滤器 对请求 进行拦截
    最简单配置：
    spring.security.user.name（和password）=admin
    普通配置：
    extends WebSecurityConfigurerAdapter
    核心3个方法，配置2个。
    protected void configure(AuthenticationManagerBuilder auth)
    配置用户和角色的（userdetails）
    public void configure(WebSecurity web)
    什么请求放行，什么请求需要认证
    protected void configure(HttpSecurity http)
    配置filter链。忽略哪些请求。
    
    最简单测试内存配置：
    PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();//单项不可逆的密码
    InMemoryUserDetailsManagerConfigurer<AuthenticationManagerBuilder> userConfig= auth.inMemoryAuthentication() .passwordEncoder(passwordEncoder);
    userConfig.withUser("admin").password("123456").authorities("ROLE_USER", "ROLE_ADMIN");
    
    authorities可写成 .roles("USER") 不需要加ROLE_
    
    普通的数据库认证（userdetails）：
    3个表。role，user，user_role 关联表
    角色表需有字段role_name用于存放：ROLE_ADMIN等角色
    用户表需有字段：user_name，pwd，available （int为1的标识，1是启用用户，0是锁死）
    关联表，多对多关系的表。需有：user_id 和 role_id字段。
    核心有两个sql:
    1，根据用户名查出用户表的所有数据：
    SELECT
    	id,
    	user_name,
    	available
    FROM
    	user
    WHERE
    	user_name = ''
    2，根据用户名查询出这个用户旗下的所有角色（3个表关联）
    
    SELECT
    	r.id,
    	r.role_name
    FROM
    	role r,
    	user_role ur,
    	user u
    WHERE
    r.id = ur.role_id
    AND ur.user_id = u.id
    AND u.user_name = ''
    
    开始构建userDetails，
    implements UserDetailsService
    查出一个用户，查出用户下的所有权限。
    new User 需要参数为用户名，密码，和 权限list
            // 权限列表
            List<GrantedAuthority> authorityList = new ArrayList<>();
            // 赋予查询到的角色
            for (DatabaseRole role : roleList) { 
                GrantedAuthority authority 
                    = new SimpleGrantedAuthority(role.getRoleName());
                authorityList.add(authority);
            }
            UserDetails userDetails = new User(dbUser.getUserName(), 
                dbUser.getPwd(), authorityList);
    
    
    依然是配置第一个方法，service即是上面构建的
    PasswordEncoder passwordEncoder = new Pbkdf2PasswordEncoder(this.secret);
     auth.userDetailsService(UserDetailsService).passwordEncoder(passwordEncoder);
    
    
    
    secret可以写在配置文件里：
    @Value("${system.secret}")
    private String secret = null;
    
    
    配置第二个方法（public void configure(WebSecurity web)），不同用户授予不同的权限。
    最简单为：
    认证的，所有请求，都能访问。启用登录。
    http.authorizeRequests().anyRequest().authenticated() （相同的是：.antMatchers("/**").permitAll()）
    .and().formLogin().and().httpBasic();
    普通配置：
              http.authorizeRequests()
                      .antMatchers("/user/welcome").hasAnyRole("USER", "ADMIN")//有任意一个即可访问
                      .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN") //需要管理员权限
                      .anyRequest().permitAll() （其他登陆后可访问，或配 anonymous()任意访问）
    
    
                      
    或者spring el通配符配置
    .antMatchers("/user/**").access("hasRole('USER') or hasRole('ADMIN')")
    .antMatchers("/admin/welcome1").access("hasAuthority('ROLE_ADMIN') && isFullyAuthenticated()")
     isFullyAuthenticated(）不能使用记住我访问
    
    .requiresSecure() 只有https才能访问。
    .requiresInsecure() 不使用https
    
    跨域请求，默认不能。可以禁用此功能。
    http.csrf().disable().authorizeRequests() 
    禁止可以csrf攻击。
    不禁止，即配合_csrf字段使用：
    <input type="hidden" id="${_csrf.parameterName}"
    name="${_csrf.parameterName}" value="${_csrf.token}" />
    
    rememberMe().tokenValiditySeconds(86400).key("remember-me-key")
    开启记住我，时间是一天，参数是秒。并设置cookie的键
    <input id="remember_me" name="remember-me" type="checkbox">
    
    自定义登录和退出页面：
     .and().formLogin().loginPage("/login/page").defaultSuccessUrl("/admin/welcome1");
     .and().logout().logoutUrl("/logout/page") .logoutSuccessUrl("/welcome");

# 起飞了 #

## security基础 ##

authentication n. 证明；鉴定；证实  
authorization n. 授权，认可；批准，委任

*  spring security 安全访问控制
 *  rest 是构建微服务 常见的系统集成的方案
 *  有些 请求 需要用户认证身份 才可以进行
 *  与第三方公司合作，需要验证合作方 身份才能进行处理业务
 *  声明式 安全访问 控制功能

### security pom ###

*  引入pom即可，默认是打开的。
 *  也可用注解：@EnableWebSecurity 开启。非web 用@EnableGlobalAuthentication。已经包含

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-security</artifactId>
    		</dependency>

*  servlet 过滤器 （filter) 对请求 进行拦截，filter通过自己的验证逻辑 来决定 是否放行请求
 *  security 也是基于这一原理， 进入 DispatcherServlet 前进行拦截，从而决定是否放行
    
     *  提供了，Dele gating Filter Proxy
     *  全注解：@EnableWebSecurity

### security 原理 ###

*  启用了 Spring Security，Ioc容器 会为你创建 spring Security Filter Chain
 *  是一个特殊的拦截器，也实现了 filter接口，类型为 ： filter chain Proxy
 *  security操作的过程中 会提供 Servlet 过滤器 Delegation Filter Proxy
 *  这个过滤器 会通过 Ioc 容器 获取 Spring Security 所创建的 Filter Chain Proxy对象
 *  这个对象存在一个拦截器列表，（用户验证，跨站点请求伪造）
 *  
 *  Filter Chain Proxy
    
     *  注册Filter，允许注册自定义的filter来实现对应的拦截请求
 *  实现了大部分常用的安全功能。并提供了相应的机制来简化 开发者的工作
 *  用户名是 user ，密码默认会打印
 *

### security 配置 ###

#自定义用户名和密码
    spring.security.user.name=myuser
    spring.security.user.password=123456

spring:
      security:
        filter:
          order: -100 #security 过滤器排序
          dispatcher-types: async,error,request #安全过滤器责任链的分发类型
    
        user:
          name: user
          password: 123456
          roles:
        oauth2:
          client:
            provider:  #oauth2 提供者详细配置信息
            registration: #客户端登记信息

### WebSecurity Configurer Adapter自定义 ###

*  FilterChainProxy对象，过滤器 DelegatingFilterProxy的拦截逻辑
 *  给 FilterChainProxy对象初始化，security提供了 SecurityConfiguration接口
 *  并且在这个接口提供了一个抽象类： WebSecurity Configurer Adapter
 *  WebSecurity Configurer Adapter

//用来配置 用户签名服务，主要配置user-details机制，给与用户赋予角色
    //auth 签名管理器构造器，用于构建用户具体权限控制
    protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
               this.disableLocalConfigureAuthenticationBldr = true;
    }
    //用来配置filter链
    public void configure(WebSecurity web) throws Exception { 
    }
    //配置拦截保护的请求，比如什么请求放行，什么请求需要认证
    protected void configure(HttpSecurity http) throws Exception { }

*  主要配置filter链，配置filtetr链 忽略哪些内容
 *  WebSecurity Configurer Adapter 提供空实现，也就是没有任何配置
 *  AuthenticationManagerBuilder auth ，定义用户，密码，角色
 *  HttpSecurity http 用户 和 角色 与 对应 URL 的访问权限。如何限定请求权限。
 *  满足通过用户验证 或 http基本验证的任何请求，都会放行。
 *  一旦通过验证，就会得到放行。

## 自定义用户信息 ##

*  WebSecurity Configurer Adapter 的方法：
    
     *  protected void configure(AuthenticationManagerBuilder auth)
 *  security 默认没有任何用户配置。
 *  boot 如果没有用户配置，将默认生成user，密码随机
 *  内存签名服务
 *  数据库签名
 *  自定义签名服务

### 使用内存签名服务 ###

*  用户测试 快速搭建环境
    
        public class TestjApplication extends WebSecurityConfigurerAdapter { 
        
            public static void main(String[] args) { 
                SpringApplication.run(TestjApplication.class, args);
            }
        
            @Override
            protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
                
                // 密码编码器
                PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
                
                // 使用内存存储 InMemoryUserDetailsManagerConfigurer<AuthenticationManagerBuilder> userConfig
                        = auth.inMemoryAuthentication()
                        // 设置密码编码器
                        .passwordEncoder(passwordEncoder);
                
                // 注册用户admin，密码为abc,并赋予USER和ADMIN的角色权限
                userConfig.withUser("admin")
                        // 可通过passwordEncoder.encode("abc")得到加密后的密码
                        .password("$2a$10$5OpFvQlTIbM9Bx2pfbKVzurdQXL9zndm1SrAjEkPyIuCcZ7CqR6je")
                        .authorities("ROLE_USER", "ROLE_ADMIN");
                
        
                // 注册用户myuser，密码为123456,并赋予USER的角色权限
                userConfig.withUser("myuser")
                        // 可通过passwordEncoder.encode("123456")得到加密后的密码
                        .password("$2a$10$ezW1uns4ZV63FgCLiFHJqOI6oR6jaaPYn33jNrxnkHZ.ayAFmfzLS")
                        .roles("USER");
            }
        }
 *  spring 5 的 security 都要密码编码器
 *  BCryptPasswordEncoder 采用的单项不可逆的密码，加密方式
 *  roles 是 authorities的缩写。.roles(“USER”) 不用加： “ROLE\_USER”
 *  and 是连接方法。.and().withUser(“admin”) 配置了一个之后，可以and
 *

*  UserDetailsBuilder
    
     *  accountExpired 是否过期
     *  accountLocked 是否锁定
     *  credentialsExpired 定义凭证是否过期
     *  disable 是否禁用用户
     *  username 定义用户名
     *  authorities 权限
     *  authorities
     *  password
     *  roles 赋予角色，会自动加入前缀 ROLE
     *

### 使用数据库定义用户认证服务 ###

*  JdbcUserDetailsManagerConfigurer

#### 创建权限表 ####

//备注：角色的数据是：ROLE_USER ROLE_ADMIN
    CREATE TABLE `t_role` (
      `id` int(12) NOT NULL,
      `role_name` varchar(60) NOT NULL,
      `note` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    //备注：用户表的密码，明文密文都是可以的
    CREATE TABLE `t_user` (
      `id` int(12) NOT NULL,
      `user_name` varchar(60) DEFAULT NULL,
      `pwd` varchar(100) DEFAULT NULL,
      `available` int(1) DEFAULT '1',
      `note` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`),
      UNIQUE KEY `user_name` (`user_name`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    CREATE TABLE `t_user_role` (
      `id` int(12) NOT NULL,
      `role_id` int(12) NOT NULL,
      `user_id` int(12) NOT NULL,
      PRIMARY KEY (`id`),
      UNIQUE KEY `role_id` (`role_id`,`user_id`),
      KEY `user_id` (`user_id`),
        
      CONSTRAINT `t_user_role_ibfk_1` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`),
      CONSTRAINT `t_user_role_ibfk_2` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

#### 使用数据库验证 ####

public class Chapter12Application extends WebSecurityConfigurerAdapter { 
    
    	// 注入数据源
    	@Autowired
    	private DataSource dataSource = null;
    
    	// 使用用户名称查询密码
    	String pwdQuery = " select user_name, pwd, available" + " from t_user where user_name = ?";
    	// 使用用户名称查询角色信息
    	String roleQuery = " select u.user_name, r.role_name " + " from t_user u, t_user_role ur, t_role r "
    			+ "where u.id = ur.user_id and r.id = ur.role_id" + " and u.user_name = ?";
    			
    			
        // 注入数据源
        @Autowired
        private DataSource dataSource = null;
    
        //对应配置文件：system.user.password.secret=uvwxyz
        @Value("${system.user.password.secret}")
        private String secret = null;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
            PasswordEncoder passwordEncoder = new Pbkdf2PasswordEncoder(this.secret);
            auth.jdbcAuthentication()
                    // 密码编码器
                    .passwordEncoder(passwordEncoder)
                    // 数据源
                    .dataSource(dataSource)
                    // 查询用户，自动判断密码是否一致
                    .usersByUsernameQuery(pwdQuery)
                    // 赋予权限
                    .authoritiesByUsernameQuery(roleQuery);
        }
    
    }

根据用户名查询密码：pwdQuery。返回用户名 密码 布尔值（判断是否有效，1是有效。0无效）
    SELECT
    	user_name,
    	pwd,
    	available
    FROM
    	t_user
    WHERE
    	user_name = ''
    	
    根据用户名查询角色信息：roleQuery	
    SELECT
    	u.user_name,
    	r.role_name
    FROM
    	t_user u,
    	t_user_role ur,
    	t_role r
    WHERE
    	u.id = ur.user_id
    AND r.id = ur.role_id
    AND u.user_name = ''

*  BCrypt 很难破译，但仍不能避免用户用123456，截取了这些简单的密码，进行匹配
 *  通过自己的钥匙对秒进行加密。
    
     *      //对应配置文件：system.user.password.secret=uvwxyz
                @Value("${system.user.password.secret}")
                private String secret = null;
            
            PasswordEncoder passwordEncoder = new Pbkdf2PasswordEncoder(this.secret);
     *  还有其他的面膜加载器：SCryptPasswordEncoder
     *  DelegatingPasswordEncoder

### 自定义用户认证信息 ###

*  数据库验证会造成网络的缓慢，可用NoSQL
 *  redis有，就从redis读取，如果没有，就从数据库查询用户信息
 *  设置用户权限 （UserDetailsService.loadUserByUsername 返回UserDetails）
    
        @Service
        public class UserDetailsServiceImpl implements UserDetailsService { 
        
        	// 注入服务接口
            @Autowired
            private UserRoleService userRoleService = null;
        
            @Override
            @Transactional
            public UserDetails loadUserByUsername(String userName) 
                    throws UsernameNotFoundException { 
                // 获取数据库用户信息
                DatabaseUser dbUser = userRoleService.getUserByName(userName); 
                // 获取数据库角色信息
                List<DatabaseRole> roleList 
                    = userRoleService.findRolesByUserName(userName);
                // 将信息转换为UserDetails对象
                return changeToUser(dbUser, roleList);
            }
            
            private UserDetails changeToUser(DatabaseUser dbUser,
                    List<DatabaseRole> roleList) { 
                // 权限列表
                List<GrantedAuthority> authorityList = new ArrayList<>();
                // 赋予查询到的角色
                for (DatabaseRole role : roleList) { 
                    GrantedAuthority authority 
                        = new SimpleGrantedAuthority(role.getRoleName());
                    authorityList.add(authority);
                }
                // 创建UserDetails对象，设置用户名、密码和权限
                UserDetails userDetails = new User(dbUser.getUserName(), 
                    dbUser.getPwd(), authorityList);
                return userDetails;
            }
        
        }
    
     *  标注@Service
     *  注入UserRoleService
     *  覆盖 loadUserByUsername
     *  UserDetails userDetails = new User

#### 注册这个认证服务 ####

public class Chapter12Application extends WebSecurityConfigurerAdapter { 
    
    
    	@Value("${system.user.password.secret}")
    	private String secret = null;
    
    	@Autowired
    	private UserDetailsService UserDetailsService = null;
    
    	/** * 覆盖WebSecurityConfigurerAdapter用户详情方法 * * @param auth * 用户签名管理器构造器 */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
    		PasswordEncoder passwordEncoder = new Pbkdf2PasswordEncoder(this.secret);//设置密码编码器
        
     auth.userDetailsService(UserDetailsService).passwordEncoder(passwordEncoder);//设置用户密码服务 和 密码编码器
    	}
        
    }

## service ##

public interface UserRoleService { 
    
    	public DatabaseUser getUserByName(String userName);
    
    	public List<DatabaseRole> findRolesByUserName(String userName);
    }
    
    
    @Service
    
    public class UserRoleServiceImpl implements UserRoleService { 
    	
    	@Autowired
    	private UserDao userDao = null;
    	@Autowired
    	private RoleDao roleDao = null;
    
    	@Override
    	@Cacheable(value = "redisCache", key = "'redis_user_'+#userName")
    	@Transactional
    	public DatabaseUser getUserByName(String userName) { 
    		return userDao.getUser(userName);
    	}
    
    	@Override
    	@Cacheable(value = "redisCache", key = "'redis_user_role_'+#userName")
    	@Transactional
    	public List<DatabaseRole> findRolesByUserName(String userName) { 
    		return roleDao.findRolesByUserName(userName);
    	}
    
    }

## dao ##

@Mapper
    public interface RoleDao { 
    	public List<DatabaseRole> findRolesByUserName(String userName);
    }
    
    @Mapper
    public interface UserDao { 
    	public DatabaseUser getUser(String userName);
    }

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.springboot.chapter12.dao.RoleDao">
      <select id="findRolesByUserName" parameterType="string" resultType="dbrole">
        SELECT r.id, r.role_name as roleName, r.note FROM t_role r, t_user_role ur, t_user u 
        where r.id = ur.role_id and ur.user_id = u.id and u.user_name = #{userName}
      </select>
    </mapper>
    
    
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.springboot.chapter12.dao.UserDao">
      <select id="getUser" parameterType="string" resultType="dbuser">
        SELECT id, user_name as userName, pwd, available, note FROM t_user where user_name = #{userName}
      </select>
    </mapper>

## action ##

@Controller
    public class WelcomeController  { 
    	
    	@Autowired
    	private UserRoleService userRoleService = null;
    	
    	@GetMapping("/welcome")
    	public String welcome() { 
    		return "welcome";
    	}
    	
    	@GetMapping("/user/details")
    	@ResponseBody
    	public DatabaseUser getUser(String userName) { 
    		return userRoleService.getUserByName(userName);
    	}
    	
    	@GetMapping("/user/welcome")
    	public String userWelcome() { 
    		return "welcome";
    	}
    	
    	@GetMapping("/admin/welcome")
    	public String adminWelcome() { 
    		return "welcome";
    	}
    	
    	@GetMapping("/admin/welcome1")
    	public String adminWelcome1() { 
    		return "welcome";
    	}
    	
    	@GetMapping("/admin/welcome2")
    	public String adminWelcome2() { 
    		return "welcome";
    	}
    	
    	@GetMapping("/csrf/form")
    	public String csrfPage() { 
    		return "csrf_form";
    	}
    	
    	@PostMapping("/csrf/commit")
    	@ResponseBody
    	public Map<String, String> csrfCommit(String name, String describe) { 
    		Map<String, String> map = new HashMap<>();
    		map.put("name", name);
    		map.put("describe", describe);
    		return map;
    	}
    	
    }

## 限制请求 ##

*  对于不同的角色 访问的权限也是不一样的
    
     *  管理员 出了登录，还需要 不同的角色 赋予 不同的权限
 *  extends WebSecurityConfigurerAdapter
    
     *  实现protected void configure(HttpSecurity http)
     *  实现对于 不同角色 （用户） 赋予不同权限的功能
    
        @Override
        	protected void configure(HttpSecurity http) throws Exception { 
        		//只需要通过验证，就能访问所有请求
        		http.authorizeRequests().anyRequest().authenticated()
        				.and().formLogin().and().httpBasic();//启用http基础 
        }
        
        只要通过用户认证，便可访问所有的请求地址
        formLogin 方法 使用security的默认登录页面 和 httpBasic方法 启用浏览器的Http基础认证方式。

#### 配置请求路径访问权限（ant风格配置限定） ####

@Override
        protected void configure(HttpSecurity http) throws Exception { 
            // 限定签名后的权限
            http.
                    /* ########第一段######## */
                            authorizeRequests()
                    // 限定"/user/welcome"请求赋予角色ROLE_USER或者ROLE_ADMIN
                    .antMatchers("/user/welcome", "/user/details").hasAnyRole("USER", "ADMIN")
                    // 限定"/admin/"下所有请求权限赋予角色ROLE_ADMIN
                    .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN")
                    // 其他路径允许签名后访问
                    .anyRequest().permitAll()
    
                    /* ######## 第二段 ######## */
                    /** and代表连接词 **/
                    // 对于没有配置权限的其他请求允许匿名访问
                    .and().anonymous()
    
                    /* ######## 第三段 ######## */
                    // 使用Spring Security默认的登录页面
                    .and().formLogin()
                    // 启动HTTP基础验证
                    .and().httpBasic();
            
            =======================本次结束===============================
            
        }

*  哪些要请求的，将不同的请求赋予不同的请求权限。
 *  antMatchers 配置请求路径
 *  hasAnyRole，指定角色
 *  .regexMatchers("/admin/.\*").hasAuthority(“ROLE\_ADMIN”) 通配符 指定
    
     *  有 admin 的权限才可以访问
     *  .hasAnyRole(“USER”, “ADMIN”) 会默认加 前缀
     *  
 *  .anyRequest().permitAll() 任意都限定的，都可访问
 *  权限方法说明
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">方法</th> 
       <th align="center">含义</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">access(Sring)</td> 
       <td align="center">参数为spEL，返回true，则允许访问</td> 
      </tr> 
      <tr> 
       <td align="center">anonymous（）</td> 
       <td align="center">允许匿名访问</td> 
      </tr> 
      <tr> 
       <td align="center">authorizeRequest()</td> 
       <td align="center">限定通过签名的请求</td> 
      </tr> 
      <tr> 
       <td align="center">anyRequest()</td> 
       <td align="center">限定任意的请求</td> 
      </tr> 
      <tr> 
       <td align="center">hasAnyRole(String …)</td> 
       <td align="center">将访问权限赋予多个角色。自动加前缀ROLE_</td> 
      </tr> 
      <tr> 
       <td align="center">hasAnyRole(String)</td> 
       <td align="center">赋予一个角色</td> 
      </tr> 
      <tr> 
       <td align="center">permitAll()</td> 
       <td align="center">无条件允许访问</td> 
      </tr> 
      <tr> 
       <td align="center">and()</td> 
       <td align="center">连接词</td> 
      </tr> 
      <tr> 
       <td align="center">httpBasic()</td> 
       <td align="center">启用浏览器的Http基础验证</td> 
      </tr> 
      <tr> 
       <td align="center">formLogin()</td> 
       <td align="center">启用security默认的登录页面</td> 
      </tr> 
      <tr> 
       <td align="center">not()</td> 
       <td align="center">对其他方法的访问采取 取反</td> 
      </tr> 
      <tr> 
       <td align="center">fullyAuthenticaticated()</td> 
       <td align="center">完整验证，允许访问（记住我功能不行）</td> 
      </tr> 
      <tr> 
       <td align="center">denyAll()</td> 
       <td align="center">无条件不允许任何访问</td> 
      </tr> 
      <tr> 
       <td align="center">hasIpAddress(String)</td> 
       <td align="center">给定的IP地址，则允许访问</td> 
      </tr> 
      <tr> 
       <td align="center">rememberme()</td> 
       <td align="center">通过remember-me功能验证就允许访问</td> 
      </tr> 
      <tr> 
       <td align="center">hasAuthority(String)</td> 
       <td align="center">给定的角色就允许访问（不加 ROLE_）</td> 
      </tr> 
      <tr> 
       <td align="center">hasAuthority(String…)</td> 
       <td align="center">给定的 任一 角色</td> 
      </tr> 
     </tbody> 
    </table>
    
     *  先配置优先
     *  把具体的配置放在前面配置，不具体的放在后面
     *

#### 使用Spring表达式 配合访问权限 ####

*  access(String) 参数为SpEL
 *  返回true，就是允许访问。

http.authorizeRequests()
        .regexMatchers("/user/welcome", "/user/details")
        .hasAnyRole("USER", "ADMIN")
        
        .regexMatchers("/admin/.*")
        .hasAuthority("ROLE_ADMIN")
        
        .and().formLogin().and().httpBasic();
              
              
              http.csrf().disable().authorizeRequests()
                      
                  // 使用Spring表达式限定只有角色ROLE_USER或者ROLE_ADMIN
                      .antMatchers("/user/**").access("hasRole('USER') or hasRole('ADMIN')")
                  
                      // 设置访问权限给角色ROLE_ADMIN，要求是完整登录(非记住我登录)
                      .antMatchers("/admin/welcome1")
                  .access("hasAuthority('ROLE_ADMIN') && isFullyAuthenticated()")
                  
                      // 限定"/admin/welcome2"访问权限给角色ROLE_ADMIN，允许不完整登录
                  .antMatchers("/admin/welcome2").access("hasAuthority('ROLE_ADMIN')")
                      
                    	// 使用记住我的功能
                      .and().rememberMe()
                      // 使用Spring Security默认的登录页面
                      .and().formLogin()
                      // 启动HTTP基础验证
                      .and().httpBasic();

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
   <th align="center">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">authentication（）</td> 
   <td align="center">用户认证对象</td> 
  </tr> 
  <tr> 
   <td align="center">denyAll()</td> 
   <td align="center">拒绝任何</td> 
  </tr> 
  <tr> 
   <td align="center">hasAnyRole(String …)</td> 
   <td align="center">当前用户是否存在参数中列明的对象属性</td> 
  </tr> 
  <tr> 
   <td align="center">hasRole(String)</td> 
   <td align="center">当前用户是否存在角色</td> 
  </tr> 
  <tr> 
   <td align="center">hasIpAddress(String)</td> 
   <td align="center">是否请求来自指定的ip</td> 
  </tr> 
  <tr> 
   <td align="center">isAnonymous()</td> 
   <td align="center">是否匿名访问</td> 
  </tr> 
  <tr> 
   <td align="center">isAuthenticated()</td> 
   <td align="center">是否通过用户认证签名</td> 
  </tr> 
  <tr> 
   <td align="center">isFullyAuthenticated（）</td> 
   <td align="center">是否用户完整验证（而非记住我）</td> 
  </tr> 
  <tr> 
   <td align="center">isRememberMe()</td> 
   <td align="center">是否通过 记住我 功能通过的验证</td> 
  </tr> 
  <tr> 
   <td align="center">permitAll()</td> 
   <td align="center">无条件允许任何访问</td> 
  </tr> 
  <tr> 
   <td align="center">principal()</td> 
   <td align="center">用户的principal对象</td> 
  </tr> 
 </tbody> 
</table>

### 强制使用 https ###

*  银行账号密码，通过https协议 采用证书 加密

@Override
    protected void configure(HttpSecurity http) throws Exception { 
    
            http.
                    //限定为https请求
                    requiresChannel().antMatchers("/admin/**").requiresSecure()
    
                    .and()
    
                    //user下不使用https请求
                    .requiresChannel().antMatchers("/user/**").requiresInsecure()
    
                    //admin下，需要admin权限
                    .and().authorizeRequests().antMatchers("/admin/**").hasAnyRole("ADMIN")
                    //user下，role 和 admin 权限都行
                    .antMatchers("/user/**").hasAnyRole("ROLE","ADMIN");
                    
    }

### 防止跨站点请求伪造 ###

*  跨站点请求伪造，CSRF cross-site request forgery
 *  浏览器请求安全网站，登录后，浏览器记录信息，以Cookie形式保存
 *  不关闭浏览器的情况下，访问一个危险网站。
 *  危险网站通过获取 cookie信息来 仿造用户的请求，进而请求安全网站
 *  security 提供 CSRF 过滤器。默认会启用这个过滤器来防止 CSRF攻击
 *  关闭如下：http.csrf().disable().authorizeRequests() （不建议）
 *  不关闭，每次HTTP请求 from 都要求存在 csrf参数
 *  当访问表单，security生成csrf参数，放入表单中
 *  当提交表单到服务器时候，就连同csrf参数一并提交
 *  security就会对csrf参数判断。
 *  如果禁止，就不会认为 请求来自 csrf攻击。
 *  这个参数不在cookie中，所以第三方网站无法伪造。

<%@ page language="java" contentType="text/html; charset=UTF-8"
             pageEncoding="UTF-8" %>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
    "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>CSRF FORM</title>
    </head>
    	<body>
    		<form action="./commit" method="post">
    			<p>
    				名称：<input id="name" name="name" type="text" value=""/>
    			</p>
    			<p>
    				描述：<input id="describe" name="describe" type="text" value=""/>
    			</p>
    			<p>
    				<input type="submit" value="提交"/>
    			</p>
    			 
    				<input type="hidden" id="${_csrf.parameterName}"
    					name="${_csrf.parameterName}" value="${_csrf.token}" />
    					 
    		</form>
    	</body>
    </html>

*  \_csrf 对象是spring提供的，会放在form的隐藏域中，
 *  默认开启了这个功能，所以要把隐藏的 $\{\_csrf.parameterName\} 标签放入
 *  如果注释了或者没有，@PostMapping("/csrf/commit") 无法被请求

### 用户认证功能 ###

#### 自定义登录页面 ####

@Override
        protected void configure(HttpSecurity http) throws Exception { 
            http.httpBasic().realmName("my-basic-name").and()
                    
                    // 访问/admin下的请求需要管理员权限
                    .authorizeRequests().antMatchers("/admin/**").access("hasRole('ADMIN')")
                    
                    // 启用remember me功能
                    .and().rememberMe().tokenValiditySeconds(86400).key("remember-me-key")
                    
                    // 启用HTTP Batic功能
                    .and().httpBasic()
                    
                    // 通过签名后可以访问任何请求
                    .and().authorizeRequests().antMatchers("/**").permitAll()
                    
                    // 设置登录页和默认的跳转路径
                    .and().formLogin().loginPage("/login/page").defaultSuccessUrl("/admin/welcome1");
        }

*  记住我的有效时间为1天，86400s
 *  cookie 以键 remember-me-key保存
 *  loginPage 登录页面
 *  defaultSuccessUrl 默认的成功页面
 *  传统的映射器映射，或 新增映射关系如下：
    
        @Configuration
        public class WebConfig implements WebMvcConfigurer { 
            // 增加映射关系
            @Override
            public void addViewControllers(ViewControllerRegistry registry) { 
                // 使得"/login/page"映射为"login.jsp"
                registry.addViewController("/login/page").setViewName("login");
                // 使得"/logout/page"映射为"logout_welcome.jsp"
                registry.addViewController("/logout/page").setViewName("logout_welcome");
                // 使得"/logout"映射为"logout.jsp"
                registry.addViewController("/logout").setViewName("logout");
            }
        }
    
        <%@ page language="java" contentType="text/html; charset=UTF-8"
            pageEncoding="UTF-8"%>
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
        "http://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>自定义登录表单</title>
        </head>
        <body>
            <form action="/login/page" method="POST">
                <p>名称：<input id="username" name="username" type="text" value=""/></p>
                <p>描述：<input id="password" name="password" type="password" value=""/></p>
                <p>记住我：<input id="remember_me" name="remember-me" type="checkbox"></p> 
                <p><input type="submit" value="登录"></p>
                <input type="hidden" id="${_csrf.parameterName}" 
                    name="${_csrf.parameterName}" value="${_csrf.token}"/>
            </form>
        </body>
        </html>
    
     *  id="$\{\_csrf.parameterName\}" 会自己加

#### 启用http Basic认证 ####

*  浏览器自动弹出简单的 模态对话框的功能
    
        http.httpBasic().realmName("my-basic-name").
    
     *  启用httpBasic认证
     *  realmName 设置模态对话框的标题

### 登出 ###

*  security提供 /logout
 *  使用http 的 post 请求这个URL，就会登出
 *  自定义退出
    
        登出之后的显示。
        logout_welcome
        <body>
           <h2>您已经登出了系统/h2>
        </body>

// 登出页面和默认跳转路径
    	        .and().logout().logoutUrl("/logout/page")
    	            .logoutSuccessUrl("/welcome");*/

## Test ##

PasswordEncoder passwordEncoder = new Pbkdf2PasswordEncoder("uvwxyz");
    		 String p1 = passwordEncoder.encode("abc");
    		 String p2 = passwordEncoder.encode("123456");
    		 //6353063b56655884e216c5f8ff6e405f6ef4e3e1f595c6f69ed088de9e910370aef46ac938979a16
    
    		 System.out.println(p1);
    		 System.out.println(p2);
    		 //每次生成的都不一样，但应该都能用
    
    Pbkdf2PasswordEncoder
    BCryptPasswordEncoder

SELECT
    	r.id,
    	r.role_name AS roleName,
    	r.note
    FROM
    	t_role r,
    	t_user_role ur,
    	t_user u
    WHERE
    	r.id = ur.role_id
    AND ur.user_id = u.id
    AND u.user_name = 'admin'
    
    10	USER	用户角色
    20	ADMIN	管理员权限
    
    
    SELECT id, user_name as userName, pwd, available, note FROM t_user where user_name = #{userName}
    
    SELECT
    	id,
    	user_name AS userName,
    	pwd,
    	available,
    	note
    FROM
    	t_user
    WHERE
    	user_name = 'admin'
    	
    	
    	1	admin	6353063b56655884e...	1	管理员备注

## redis缓存配置 ##

### 引入 pom ###

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-aop</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-security</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		//还有jsp的两个包
    
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-jdbc</artifactId>
    			<scope>provided</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>org.mybatis.spring.boot</groupId>
    			<artifactId>mybatis-spring-boot-starter</artifactId>
    			<version>1.3.1</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    			<exclusions>
    				
    				<exclusion>
    					<groupId>io.lettuce</groupId>
    					<artifactId>lettuce-core</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-pool2</artifactId>
    		</dependency>

### 配置 ###

#Redis配置
    spring.redis.jedis.pool.min-idle=5
    spring.redis.jedis.pool.max-active=10
    spring.redis.jedis.pool.max-idle=10
    spring.redis.jedis.pool.max-wait=2000
    spring.redis.port=6379
    spring.redis.host=192.168.2.198
    #spring.redis.password=123456
    
    spring.cache.type=REDIS
    spring.cache.cache-names=redisCache
    # 禁用前缀
    spring.cache.redis.use-key-prefix=false
    # 允许保存空值
    #spring.cache.redis.cache-null-values=true
    # 自定义前缀
    #spring.cache.redis.key-prefix=
    # 定义超时时间，单位毫秒
    spring.cache.redis.time-to-live=600000

### 初始化 ###

@Autowired
    	private RedisTemplate redisTemplate = null;
    
    	@PostConstruct
    	public void initRedisTemplate() { 
    		RedisSerializer<String> strSerializer = redisTemplate.getStringSerializer();
    		redisTemplate.setKeySerializer(strSerializer);
    		redisTemplate.setHashKeySerializer(strSerializer);
    	}

### 使用 ###

@Service
    public class UserRoleServiceImpl implements UserRoleService { 
    	@Autowired
    	private UserDao userDao = null;
    	@Autowired
    	private RoleDao roleDao = null;
    
    	@Override
    	@Cacheable(value = "redisCache", key = "'redis_user_'+#userName")
    	@Transactional
    	public DatabaseUser getUserByName(String userName) { 
    		return userDao.getUser(userName);
    	}
    
    	@Override
    	@Cacheable(value = "redisCache", key = "'redis_user_role_'+#userName")
    	@Transactional
    	public List<DatabaseRole> findRolesByUserName(String userName) { 
    		return roleDao.findRolesByUserName(userName);
    	}
    }

## jsp ##