权限认证框架(UAAC)

// 在登录时写入当前会话的账号id
StpUtil.login(10001);

// 然后在需要校验登录处调用以下方法：
// 如果当前会话未登录，这句代码会抛出 `NotLoginException` 异常
StpUtil.checkLogin();

@CpCheckPermission("user:add")
@RequestMapping("/user/insert")
public String insert(SysUser user) {
	// ... 
	return "用户增加";
}

// 将账号id为 10001 的会话踢下线 
StpUtil.kickout(10001);

StpUtil.login(10001);    // 标记当前会话登录的账号id
StpUtil.getLoginId();    // 获取当前会话登录的账号id
StpUtil.isLogin();    // 获取当前会话是否已经登录, 返回true或false
StpUtil.logout();    // 当前会话注销登录
StpUtil.kickout(10001);    // 将账号为10001的会话踢下线
StpUtil.hasRole("super-admin");    // 查询当前账号是否含有指定角色标识, 返回true或false
StpUtil.hasPermission("user:add");    // 查询当前账号是否含有指定权限, 返回true或false
StpUtil.getSession();    // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001);    // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001);    // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC");    // 指定设备标识登录，常用于“同端互斥登录”
StpUtil.kickout(10001, "PC");    // 指定账号指定设备标识踢下线 (不同端不受影响)
StpUtil.openSafe(120);    // 在当前会话开启二级认证，有效期为120秒 
StpUtil.checkSafe();    // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常 
StpUtil.switchTo(10044);    // 将当前会话身份临时切换为其它账号 

server:
	# 端口
    port: 8081
	
### UAAC配置
uaac: 
	# token名称 (同时也是cookie名称)
	token-name: uaac-token
	# token有效期，单位s 默认30天, -1代表永不过期 
	timeout: 2592000
	# token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
	activity-timeout: -1
	# 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
	is-concurrent: true
	# 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
	is-share: false
	# token风格
	token-style: uuid
	# 是否输出操作日志 
	is-log: false

@SpringBootApplication
public class UaacDemoApplication {
	public static void main(String[] args) throws JsonProcessingException {
		SpringApplication.run(UaacDemoApplication.class, args);
		System.out.println("启动成功：UAAC配置如下：" + CpManager.getConfig());
	}
}

@RestController
@RequestMapping("/user/")
public class UserController {

	// 测试登录，浏览器访问： http://localhost:8081/user/doLogin?username=zhang&password=123456
	@RequestMapping("doLogin")
	public String doLogin(String username, String password) {
		// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对 
		if("zhang".equals(username) && "123456".equals(password)) {
			StpUtil.login(10001);
			return "登录成功";
		}
		return "登录失败";
	}

	// 查询登录状态，浏览器访问： http://localhost:8081/user/isLogin
	@RequestMapping("isLogin")
	public String isLogin() {
		return "当前会话是否登录：" + StpUtil.isLogin();
	}
	
}

@SpringBootApplication
public class UaacDemoApplication {
	public static void main(String[] args) throws JsonProcessingException {
		SpringApplication.run(UaacDemoApplication.class, args);
		System.out.println("启动成功：UAAC配置如下：" + CpManager.getConfig());
	}
}

/**
 * [UAAC 权限认证] 全局配置类 
 */
@Configuration
public class CpTokenConfigure {
	/**
     * 注册 [UAAC全局过滤器] 
     */
    @Bean
    public CpReactorFilter getCpReactorFilter() {
        return new CpReactorFilter()
        		// 指定 [拦截路由]
        		.addInclude("/**")
        		// 指定 [放行路由]
        		.addExclude("/favicon.ico")
        		// 指定[认证函数]: 每次请求执行 
        		.setAuth(obj -> {
        			System.out.println("---------- uaac全局认证");
                    // CpRouter.match("/test/test", () -> StpUtil.checkLogin());
        		})
        		// 指定[异常处理函数]：每次[认证函数]发生异常时执行此函数 
        		.setError(e -> {
        			System.out.println("---------- sa全局异常 ");
        			return AjaxJson.getError(e.getMessage());
        		})
        		;
    }
}

@RestController
@RequestMapping("/user/")
public class UserController {

	// 测试登录，浏览器访问： http://localhost:8081/user/doLogin?username=zhang&password=123456
	@RequestMapping("doLogin")
	public String doLogin(String username, String password) {
		// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对 
		if("zhang".equals(username) && "123456".equals(password)) {
			StpUtil.login(10001);
			return "登录成功";
		}
		return "登录失败";
	}

	// 查询登录状态，浏览器访问： http://localhost:8081/user/isLogin
	@RequestMapping("isLogin")
	public String isLogin() {
		return "当前会话是否登录：" + StpUtil.isLogin();
	}
	
}

// 标记当前会话登录的账号id 
// 建议的参数类型：long | int | String， 不可以传入复杂类型，如：User、Admin等等
StpUtil.login(Object id);	 

// 当前会话注销登录
StpUtil.logout();

// 获取当前会话是否已经登录，返回true=已登录，false=未登录
StpUtil.isLogin();

// 检验当前会话是否已经登录, 如果未登录，则抛出异常：`NotLoginException`
StpUtil.checkLogin()

// 获取当前会话账号id, 如果未登录，则抛出异常：`NotLoginException`
StpUtil.getLoginId();

// 类似查询API还有：
StpUtil.getLoginIdAsString();    // 获取当前会话账号id, 并转化为`String`类型
StpUtil.getLoginIdAsInt();       // 获取当前会话账号id, 并转化为`int`类型
StpUtil.getLoginIdAsLong();      // 获取当前会话账号id, 并转化为`long`类型

// ---------- 指定未登录情形下返回的默认值 ----------

// 获取当前会话账号id, 如果未登录，则返回null 
StpUtil.getLoginIdDefaultNull();

// 获取当前会话账号id, 如果未登录，则返回默认值 （`defaultValue`可以为任意类型）
StpUtil.getLoginId(T defaultValue);

// 获取指定token对应的账号id，如果未登录，则返回 null
StpUtil.getLoginIdByToken(String tokenValue);

// 获取当前`StpLogic`的token名称
StpUtil.getTokenName();

// 获取当前会话的token值
StpUtil.getTokenValue();

// 获取当前会话的token信息参数
StpUtil.getTokenInfo();

/**
 * 登录测试 
 *
 */
@RestController
@RequestMapping("/acc/")
public class LoginController {

	// 测试登录  ---- http://localhost:8081/acc/doLogin?name=zhang&pwd=123456
	@RequestMapping("doLogin")
	public CpResult doLogin(String name, String pwd) {
		// 此处仅作模拟示例，真实项目需要从数据库中查询数据进行比对 
		if("zhang".equals(name) && "123456".equals(pwd)) {
			StpUtil.login(10001);
			return CpResult.ok("登录成功");
		}
		return CpResult.error("登录失败");
	}

	// 查询登录状态  ---- http://localhost:8081/acc/isLogin
	@RequestMapping("isLogin")
	public CpResult isLogin() {
		return CpResult.ok("是否登录：" + StpUtil.isLogin());
	}
	
	// 查询 Token 信息  ---- http://localhost:8081/acc/tokenInfo
	@RequestMapping("tokenInfo")
	public CpResult tokenInfo() {
		return CpResult.data(StpUtil.getTokenInfo());
	}
	
	// 测试注销  ---- http://localhost:8081/acc/logout
	@RequestMapping("logout")
	public CpResult logout() {
		StpUtil.logout();
		return CpResult.ok();
	}
	
}

package com.example.uaac;

import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Component;
import com.cpit.csc.uaac.stp.StpInterface;

/**
 * 自定义权限验证接口扩展 
 */
@Component	// 保证此类被SpringBoot扫描，完成UAAC的自定义权限验证扩展 
public class StpInterfaceImpl implements StpInterface {

	/**
	 * 返回一个账号所拥有的权限码集合 
	 */
	@Override
	public List<String> getPermissionList(Object loginId, String loginType) {
		// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询权限
		List<String> list = new ArrayList<String>();	
		list.add("101");
		list.add("user-add");
		list.add("user-delete");
		list.add("user-update");
		list.add("user-get");
		list.add("article-get");
		return list;
	}

	/**
	 * 返回一个账号所拥有的角色标识集合 (权限与角色可分开校验)
	 */
	@Override
	public List<String> getRoleList(Object loginId, String loginType) {
		// 本list仅做模拟，实际项目中要根据具体业务逻辑来查询角色
		List<String> list = new ArrayList<String>();	
		list.add("admin");
		list.add("super-admin");
		return list;
	}

}

// 判断：当前账号是否含有指定权限, 返回true或false
StpUtil.hasPermission("user-update");		

// 校验：当前账号是否含有指定权限, 如果验证未通过，则抛出异常: NotPermissionException 
StpUtil.checkPermission("user-update");		

// 校验：当前账号是否含有指定权限 [指定多个，必须全部验证通过]
StpUtil.checkPermissionAnd("user-update", "user-delete");		

// 校验：当前账号是否含有指定权限 [指定多个，只要其一验证通过即可]
StpUtil.checkPermissionOr("user-update", "user-delete");		

// 判断：当前账号是否拥有指定角色, 返回true或false
StpUtil.hasRole("super-admin");		

// 校验：当前账号是否含有指定角色标识, 如果验证未通过，则抛出异常: NotRoleException
StpUtil.checkRole("super-admin");		

// 校验：当前账号是否含有指定角色标识 [指定多个，必须全部验证通过]
StpUtil.checkRoleAnd("super-admin", "shop-admin");		

// 校验：当前账号是否含有指定角色标识 [指定多个，只要其一验证通过即可] 
StpUtil.checkRoleOr("super-admin", "shop-admin");		

// 当拥有 user* 权限时
StpUtil.hasPermission("user-add");        // true
StpUtil.hasPermission("user-update");     // true
StpUtil.hasPermission("art-add");         // false

// 当拥有 *-delete 权限时
StpUtil.hasPermission("user-add");        // false
StpUtil.hasPermission("user-delete");     // true
StpUtil.hasPermission("art-delete");      // true

// 当拥有 *.js 权限时
StpUtil.hasPermission("index.js");        // true
StpUtil.hasPermission("index.css");       // false
StpUtil.hasPermission("index.html");      // false

StpUtil.logout(10001);                    // 强制指定账号注销下线 
StpUtil.logout(10001, "PC");              // 强制指定账号指定端注销下线 
StpUtil.logoutByTokenValue("token");      // 强制指定 Token 注销下线 

StpUtil.kickout(10001);                    // 将指定账号踢下线 
StpUtil.kickout(10001, "PC");              // 将指定账号指定端踢下线
StpUtil.kickoutByTokenValue("token");      // 将指定 Token 踢下线

// 封禁指定账号 
// 参数一：账号id
// 参数二：封禁时长，单位：秒  (86400秒=1天，此值为-1时，代表永久封禁)
StpUtil.disable(10001, 86400); 

// 获取指定账号是否已被封禁 (true=已被封禁, false=未被封禁) 
StpUtil.isDisable(10001); 

// 获取指定账号剩余封禁时间，单位：秒
StpUtil.getDisableTime(10001); 

// 解除封禁
StpUtil.untieDisable(10001); 

// 先踢下线
StpUtil.kickout(10001); 
// 再封禁账号
StpUtil.disable(10001, 86400); 

@Configuration
public class CpConfigure implements WebMvcConfigurer {
	// 注册UAAC的注解拦截器，打开注解式鉴权功能 
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 注册注解拦截器，并排除不需要注解鉴权的接口地址 (与登录拦截器无关)
		registry.addInterceptor(new CpAnnotationInterceptor()).addPathPatterns("/**");	
	}
}

// 登录认证：只有登录之后才能进入该方法 
@CpCheckLogin						
@RequestMapping("info")
public String info() {
	return "查询用户信息";
}

// 角色认证：必须具有指定角色才能进入该方法 
@CpCheckRole("super-admin")		
@RequestMapping("add")
public String add() {
	return "用户增加";
}

// 权限认证：必须具有指定权限才能进入该方法 
@CpCheckPermission("user-add")		
@RequestMapping("add")
public String add() {
	return "用户增加";
}

// 二级认证：必须二级认证之后才能进入该方法 
@CpCheckSafe()		
@RequestMapping("add")
public String add() {
	return "用户增加";
}

// Http Basic 认证：只有通过 Basic 认证后才能进入该方法 
@CpCheckBasic(account = "uaac:123456")
@RequestMapping("add")
public String add() {
	return "用户增加";
}

// 注解式鉴权：只要具有其中一个权限即可通过校验 
@RequestMapping("atJurOr")
@CpCheckPermission(value = {"user-add", "user-all", "user-delete"}, mode = CpMode.OR)		
public AjaxJson atJurOr() {
	return AjaxJson.getSuccessData("用户信息");
}

// 注解式鉴权：只要具有其中一个权限即可通过校验 
@RequestMapping("userAdd")
@CpCheckPermission(value = "user-add", orRole = "admin")		
public AjaxJson userAdd() {
	return AjaxJson.getSuccessData("用户信息");
}

@Configuration
public class CpConfigure implements WebMvcConfigurer {
	// 注册拦截器
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 注册UAAC的路由拦截器
		registry.addInterceptor(new CpRouteInterceptor())
			.addPathPatterns("/**")
			.excludePathPatterns("/user/doLogin"); 
	}
}

@Configuration
public class CpTokenConfigure implements WebMvcConfigurer {
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 注册路由拦截器，自定义认证规则 
		registry.addInterceptor(new CpRouteInterceptor((req, res, handler)->{
			// 根据路由划分模块，不同模块不同鉴权 
			CpRouter.match("/user/**", r -> StpUtil.checkPermission("user"));
			CpRouter.match("/admin/**", r -> StpUtil.checkPermission("admin"));
			CpRouter.match("/goods/**", r -> StpUtil.checkPermission("goods"));
			CpRouter.match("/orders/**", r -> StpUtil.checkPermission("orders"));
			CpRouter.match("/notice/**", r -> StpUtil.checkPermission("notice"));
			CpRouter.match("/comment/**", r -> StpUtil.checkPermission("comment"));
		})).addPathPatterns("/**");
	}
}

@Configuration
public class CpTokenConfigure implements WebMvcConfigurer {
	// 注册UAAC的拦截器
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 注册路由拦截器，自定义认证规则 
		registry.addInterceptor(new CpRouteInterceptor((req, res, handler) -> {
			
			// 登录认证 -- 拦截所有路由，并排除/user/doLogin 用于开放登录 
			CpRouter.match("/**", "/user/doLogin", r -> StpUtil.checkLogin());

			// 角色认证 -- 拦截以 admin 开头的路由，必须具备 admin 角色或者 super-admin 角色才可以通过认证 
			CpRouter.match("/admin/**", r -> StpUtil.checkRoleOr("admin", "super-admin"));

			// 权限认证 -- 不同模块认证不同权限 
			CpRouter.match("/user/**", r -> StpUtil.checkPermission("user"));
			CpRouter.match("/admin/**", r -> StpUtil.checkPermission("admin"));
			CpRouter.match("/goods/**", r -> StpUtil.checkPermission("goods"));
			CpRouter.match("/orders/**", r -> StpUtil.checkPermission("orders"));
			CpRouter.match("/notice/**", r -> StpUtil.checkPermission("notice"));
			CpRouter.match("/comment/**", r -> StpUtil.checkPermission("comment"));
			
			// 甚至你可以随意的写一个打印语句
			CpRouter.match("/**", r -> System.out.println("----啦啦啦----"));

            // 连缀写法
            CpRouter.match("/**").check(r -> System.out.println("----啦啦啦----"));
			
		})).addPathPatterns("/**");
	}
}

// 基础写法样例：匹配一个path，执行一个校验函数 
CpRouter.match("/user/**").check(r -> StpUtil.checkLogin());

// 根据 path 路由匹配   ——— 支持写多个path，支持写 restful 风格路由 
CpRouter.match("/user/**", "/goods/**", "/art/get/{id}").check( /* 要执行的校验函数 */ );

// 根据 path 路由排除匹配 
CpRouter.match("/**").notMatch("*.html", "*.css", "*.js").check( /* 要执行的校验函数 */ );

// 根据请求类型匹配 
CpRouter.match(CpHttpMethod.GET).check( /* 要执行的校验函数 */ );

// 根据一个 boolean 条件进行匹配 
CpRouter.match( StpUtil.isLogin() ).check( /* 要执行的校验函数 */ );

// 根据一个返回 boolean 结果的lambda表达式匹配 
CpRouter.match( r -> StpUtil.isLogin() ).check( /* 要执行的校验函数 */ );

// 多个条件一起使用 
CpRouter.match(CpHttpMethod.GET).match("/**").check( /* 要执行的校验函数 */ );

// 可以无限连缀下去 
CpRouter
	.match(CpHttpMethod.GET)
	.match("/admin/**")
	.match("/user/**") 
	.notMatch("/**/*.js")
	.notMatch("/**/*.css")
	// ....
	.check( /* 只有上述所有条件都匹配成功，才会执行最后的check校验函数 */ );

registry.addInterceptor(new CpRouteInterceptor((req, res, handler) -> {
	CpRouter.match("/**").check(r -> System.out.println("进入1"));
	CpRouter.match("/**").check(r -> System.out.println("进入2")).stop();
	CpRouter.match("/**").check(r -> System.out.println("进入3"));
})).addPathPatterns("/**");

// 执行back函数后将停止匹配，也不会进入Controller，而是直接将 back参数 作为返回值输出到前端
CpRouter.match("/user/back").back("参数");

// 进入 free 独立作用域 
CpRouter.match("/**").free(r -> {
	CpRouter.match("/a/**").check(/* --- */);
	CpRouter.match("/a/**").check(/* --- */).stop();
	CpRouter.match("/a/**").check(/* --- */);
});
// 执行 stop() 函数跳出 free 后继续执行下面的 match 匹配 
CpRouter.match("/**").check(/* --- */);

// 在登录时缓存user对象 
StpUtil.getSession().set("user", user);

// 然后我们就可以在任意处使用这个user对象
SysUser user = (SysUser) StpUtil.getSession().get("user");

// 获取当前账号id的Session (必须是登录后才能调用)
StpUtil.getSession();

// 获取当前账号id的Session, 并决定在Session尚未创建时，是否新建并返回
StpUtil.getSession(true);

// 获取账号id为10001的Session
StpUtil.getSessionByLoginId(10001);

// 获取账号id为10001的Session, 并决定在Session尚未创建时，是否新建并返回
StpUtil.getSessionByLoginId(10001, true);

// 获取SessionId为xxxx-xxxx的Session, 在Session尚未创建时, 返回null 
StpUtil.getSessionBySessionId("xxxx-xxxx");

// 获取当前token的专属Session 
StpUtil.getTokenSession();

// 获取指定token的专属Session 
StpUtil.getTokenSessionByToken(token);

// 查询指定key的Session是否存在
CpSessionCustomUtil.isExists("goods-10001");

// 获取指定key的Session，如果没有，则新建并返回
CpSessionCustomUtil.getSessionById("goods-10001");

// 获取指定key的Session，如果没有，第二个参数决定是否新建并返回  
CpSessionCustomUtil.getSessionById("goods-10001", false);   

// 删除指定key的Session
CpSessionCustomUtil.deleteSessionById("goods-10001");

// 返回此Session的id 
session.getId();                          

// 返回此Session的创建时间 (时间戳) 
session.getCreateTime();                  

// 在Session上获取一个值 
session.getAttribute('name');             

// 在Session上获取一个值，并指定取不到值时返回的默认值
session.getAttribute('name', 'zhang');    

// 在Session上写入一个值 
session.setAttribute('name', 'zhang');    

// 在Session上移除一个值 
session.removeAttribute('name');          

// 清空此Session的所有值 
session.clearAttribute();                 

// 获取此Session是否含有指定key (返回true或false)
session.containsAttribute('name');        

// 获取此Session会话上所有key (返回Set<String>)
session.attributeKeys();                  

// 返回此Session会话上的底层数据对象（如果更新map里的值，请调用session.update()方法避免产生脏数据）
session.getDataMap();                     

// 将这个Session从持久库更新一下
session.update();                         

// 注销此Session会话 (从持久库删除此Session)
session.logout();                         

// 写值 
session.set("name", "zhang"); 

// 写值 (只有在此key原本无值的时候才会写入)
session.setDefaultValue("name", "zhang");

// 取值
session.get("name");

// 取值 (指定默认值)
session.get("name", "<defaultValue>"); 

// 取值 (转String类型)
session.getString("name"); 

// 取值 (转int类型)
session.getInt("age"); 

// 取值 (转long类型)
session.getLong("age"); 

// 取值 (转double类型)
session.getDouble("result"); 

// 取值 (转float类型)
session.getFloat("result"); 

// 取值 (指定转换类型)
session.getModel("key", Student.class); 

// 取值 (指定转换类型, 并指定值为Null时返回的默认值)
session.getModel("key", Student.class, <defaultValue>); 

// 是否含有某个key
session.has("key"); 

@PostMapping("/resetPoints")
public void reset(HttpSession session) {
	// 在HttpSession上写入一个值 
    session.setAttribute("name", 66);
	// 在CpSession进行取值
    System.out.println(StpUtil.getSession().getAttribute("name"));	// 输出null
}

### UAAC 配置
uaac: 
	# token名称 (同时也是cookie名称)
	token-name: uaac-token
	# token有效期，单位s 默认30天, -1代表永不过期 
	timeout: 2592000
	# token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
	activity-timeout: -1
	# 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
	is-concurrent: true
	# 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
	is-share: true
	# token风格
	token-style: uuid
	# 是否输出操作日志 
	is-log: false

/**
 * UAAC代码方式进行配置
 */
@Configuration
public class CpTokenConfigure {

	// 获取配置Bean (以代码的方式配置UAAC, 此配置会覆盖yml中的配置)
    @Bean
    @Primary
    public CpConfig getCpConfigPrimary() {
		CpConfig config = new CpConfig();
		config.setTokenName("uaac-token");             // token名称 (同时也是cookie名称)
		config.setTimeout(30 * 24 * 60 * 60);       // token有效期，单位s 默认30天
		config.setActivityTimeout(-1);              // token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
		config.setIsConcurrent(true);               // 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录) 
		config.setIsShare(true);                    // 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token) 
		config.setTokenStyle("uuid");               // token风格 
		config.setIsLog(false);                     // 是否输出操作日志 
		return config;
	}
	
}

// 以代码的方式配置UAAC-Config 
@Autowired
public void configUAAC(CpConfig config) {
	// config.setTokenName("uaac-token333");             // token名称 (同时也是cookie名称)
	// ... 
}

### 端口
spring: 
    # redis配置 
    redis:
        # Redis数据库索引（默认为0）
        database: 1
        # Redis服务器地址
        host: 127.0.0.1
        # Redis服务器连接端口
        port: 6379
        # Redis服务器连接密码（默认为空）
        # password: 
        # 连接超时时间
        timeout: 10s
        lettuce:
            pool:
                # 连接池最大连接数
                max-active: 200
                # 连接池最大阻塞等待时间（使用负值表示没有限制）
                max-wait: -1ms
                # 连接池中的最大空闲连接
                max-idle: 10
                # 连接池中的最小空闲连接
                min-idle: 0

// 1. token-style=uuid    —— uuid风格 (默认风格)
"623368f0-ae5e-4475-a53f-93e4225f16ae"

// 2. token-style=simple-uuid    —— 同上，uuid风格, 只不过去掉了中划线
"6fd4221395024b5f87edd34bc3258ee8"

// 3. token-style=random-32    —— 随机32位字符串
"qEjyPsEA1Bkc9dr8YP6okFr5umCZNR6W"

// 4. token-style=random-64    —— 随机64位字符串
"v4ueNLEpPwMtmOPMBtOOeIQsvP8z9gkMgIVibTUVjkrNrlfra5CGwQkViDjO8jcc"

// 5. token-style=random-128    —— 随机128位字符串
"nojYPmcEtrFEaN0Otpssa8I8jpk8FO53UcMZkCP9qyoHaDbKS6dxoRPky9c6QlftQ0pdzxRGXsKZmUSrPeZBOD6kJFfmfgiRyUmYWcj4WU4SSP2ilakWN1HYnIuX0Olj"

// 6. token-style=tik    —— tik风格
"gr_SwoIN0MC1ewxHX_vfCW3BothWDZMMtx__"

@Configuration
public class CpTokenConfigure {
    /**
     * 重写 UAAC 框架内部算法策略 
     */
    @Autowired
    public void rewriteCpStrategy() {
    	// 重写 Token 生成策略 
    	CpStrategy.me.createToken = (loginId, loginType) -> {
    		return CpFoxUtil.getRandomString(60);	// 随机60位长度字符串
    	};
    }
}

uaac: 
	# token前缀
	token-prefix: Bearer

// 设置登录账号id为10001，第二个参数指定是否为[记住我]，当此值为false后，关闭浏览器后再次打开需要重新登录
StpUtil.login(10001, false);

// 示例1：
// 指定token有效期(单位: 秒)，如下所示token七天有效
StpUtil.login(10001, new CpLoginModel().setTimeout(60 * 60 * 24 * 7));

// ----------------------- 示例2：所有参数
// `CpLoginModel`为登录参数Model，其有诸多参数决定登录时的各种逻辑，例如：
StpUtil.login(10001, new CpLoginModel()
			.setDevice("PC")				// 此次登录的客户端设备标识, 用于[同端互斥登录]时指定此次登录的设备名称
			.setIsLastingCookie(true)		// 是否为持久Cookie（临时Cookie在浏览器关闭时会自动删除，持久Cookie在重新打开后依然存在）
			.setTimeout(60 * 60 * 24 * 7)	// 指定此次登录token的有效期, 单位:秒 （如未指定，自动取全局配置的timeout值）
			);

// 获取指定账号10001的`tokenValue`值 
StpUtil.getTokenValueByLoginId(10001);

// 将账号10001的会话注销登录
StpUtil.logout(10001);

// 获取账号10001的Session对象, 如果session尚未创建, 则新建并返回
StpUtil.getSessionByLoginId(10001);

// 获取账号10001的Session对象, 如果session尚未创建, 则返回null 
StpUtil.getSessionByLoginId(10001, false);

// 获取账号10001是否含有指定角色标识 
StpUtil.hasRole(10001, "super-admin");

// 获取账号10001是否含有指定权限码
StpUtil.hasPermission(10001, "user:add");

// 将当前会话[身份临时切换]为其它账号 
StpUtil.switchTo(10044);

// 此时再调用此方法会返回 10044 (我们临时切换到的账号id)
StpUtil.getLoginId();

// 结束 [身份临时切换]
StpUtil.endSwitch();

System.out.println("------- [身份临时切换]调用开始...");
StpUtil.switchTo(10044, () -> {
	System.out.println("是否正在身份临时切换中: " + StpUtil.isSwitch()); 
	System.out.println("获取当前登录账号id: " + StpUtil.getLoginId());
});
System.out.println("------- [身份临时切换]调用结束...");

// 指定`账号id`和`设备标识`进行登录
StpUtil.login(10001, "PC");	

// 指定`账号id`和`设备标识`进行强制注销 
StpUtil.logout(10001, "PC");	

// 返回当前token的登录设备
StpUtil.getLoginDevice();	

// 获取指定loginId指定设备端的tokenValue 
StpUtil.getTokenValueByLoginId(10001, "APP");	

// 在当前会话 开启二级认证，时间为120秒
StpUtil.openSafe(120); 

// 获取：当前会话是否处于二级认证时间内
StpUtil.isSafe(); 

// 检查当前会话是否已通过二级认证，如未通过则抛出异常
StpUtil.checkSafe(); 

// 获取当前会话的二级认证剩余有效时间 (单位: 秒, 返回-2代表尚未通过二级认证)
StpUtil.getSafeTime(); 

// 在当前会话 结束二级认证
StpUtil.closeSafe(); 

// 二级认证：必须二级认证之后才能进入该方法 
@CpCheckSafe      
@RequestMapping("add")
public String add() {
    return "用户增加";
}

@RequestMapping("test3")
public CpResult test3() {
	CpBasicUtil.check("uaac:123456");
	return CpResult.ok();
}

// 对当前会话进行 Basic 校验，账号密码为 yml 配置的值（例如：uaac.basic=uaac:123456）
CpBasicUtil.check();

// 对当前会话进行 Basic 校验，账号密码为：`uaac / 123456`
CpBasicUtil.check("uaac:123456");

// 以注解方式启用 Basic 校验
@CpCheckBasic(account = "uaac:123456")
@RequestMapping("test3")
public CpResult test3() {
	return CpResult.ok();
}

// 在全局拦截器 或 过滤器中启用 Basic 认证 
@Bean
public CpServletFilter getCpServletFilter() {
	return new CpServletFilter()
			.addInclude("/**").addExclude("/favicon.ico")
			.setAuth(obj -> {
				CpRouter.match("/test/**", () -> CpBasicUtil.check("uaac:123456"));
			});
}

// md5加密 
CpSecureUtil.md5("123456");

// sha1加密 
CpSecureUtil.sha1("123456");

// sha256加密 
CpSecureUtil.sha256("123456");

// md5加盐加密: md5(md5(str) + md5(salt)) 
CpSecureUtil.md5BySalt("123456", "salt");

// 定义秘钥和明文
String key = "123456";
String text = "UAAC 一个轻量级java权限认证框架";

// 加密 
String ciphertext = CpSecureUtil.aesEncrypt(key, text);
System.out.println("AES加密后：" + ciphertext);

// 解密 
String text2 = CpSecureUtil.aesDecrypt(key, ciphertext);
System.out.println("AES解密后：" + text2);

// 定义私钥和公钥 
String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAO+wmt01pwm9lHMdq7A8gkEigk0XKMfjv+4IjAFhWCSiTeP7dtlnceFJbkWxvbc7Qo3fCOpwmfcskwUc3VSgyiJkNJDs9ivPbvlt8IU2bZ+PBDxYxSCJFrgouVOpAr8ar/b6gNuYTi1vt3FkGtSjACFb002/68RKUTye8/tdcVilAgMBAAECgYA1COmrSqTUJeuD8Su9ChZ0HROhxR8T45PjMmbwIz7ilDsR1+E7R4VOKPZKW4Kz2VvnklMhtJqMs4MwXWunvxAaUFzQTTg2Fu/WU8Y9ha14OaWZABfChMZlpkmpJW9arKmI22ZuxCEsFGxghTiJQ3tK8npj5IZq5vk+6mFHQ6aJAQJBAPghz91Dpuj+0bOUfOUmzi22obWCBncAD/0CqCLnJlpfOoa9bOcXSusGuSPuKy5KiGyblHMgKI6bq7gcM2DWrGUCQQD3SkOcmia2s/6i7DUEzMKaB0bkkX4Ela/xrfV+A3GzTPv9bIBamu0VIHznuiZbeNeyw7sVo4/GTItq/zn2QJdBAkEA8xHsVoyXTVeShaDIWJKTFyT5dJ1TR++/udKIcuiNIap34tZdgGPI+EM1yoTduBM7YWlnGwA9urW0mj7F9e9WIQJAFjxqSfmeg40512KP/ed/lCQVXtYqU7U2BfBTg8pBfhLtEcOg4wTNTroGITwe2NjL5HovJ2n2sqkNXEio6Ji0QQJAFLW1Kt80qypMqot+mHhS+0KfdOpaKeMWMSR4Ij5VfE63WzETEeWAMQESxzhavN1WOTb3/p6icgcVbgPQBaWhGg==";
String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDvsJrdNacJvZRzHauwPIJBIoJNFyjH47/uCIwBYVgkok3j+3bZZ3HhSW5Fsb23O0KN3wjqcJn3LJMFHN1UoMoiZDSQ7PYrz275bfCFNm2fjwQ8WMUgiRa4KLlTqQK/Gq/2+oDbmE4tb7dxZBrUowAhW9NNv+vESlE8nvP7XXFYpQIDAQAB";

// 文本
String text = "UAAC 一个轻量级java权限认证框架";

// 使用公钥加密
String ciphertext = CpSecureUtil.rsaEncryptByPublic(publicKey, text);
System.out.println("公钥加密后：" + ciphertext);

// 使用私钥解密
String text2 = CpSecureUtil.rsaDecryptByPrivate(privateKey, ciphertext);
System.out.println("私钥解密后：" + text2); 

// 生成一对公钥和私钥，其中Map对象 (private=私钥, public=公钥)
System.out.println(CpSecureUtil.rsaGenerateKeyPair());

// 文本
String text = "UAAC 一个轻量级java权限认证框架";

// 使用Base64编码
String base64Text = CpBase64Util.encode(text);
System.out.println("Base64编码后：" + base64Text);

// 使用Base64解码
String text2 = CpBase64Util.decode(base64Text);
System.out.println("Base64解码后：" + text2); 

// 查询所有token
StpUtil.searchTokenValue(String keyword, int start, int size);

// 查询所有账号Session会话
StpUtil.searchSessionId(String keyword, int start, int size);

// 查询所有令牌Session会话
StpUtil.searchTokenSessionId(String keyword, int start, int size);

// 查询value包括1000的所有token，结果集从第0条开始，返回10条
List<String> tokenList = StpUtil.searchTokenValue("1000", 0, 10);	
for (String token : tokenList) {
	System.out.println(token);
}

/**
 * 自定义侦听器的实现 
 */
@Component
public class MyCpListener implements CpListener {

	/** 每次登录时触发 */
	@Override
	public void doLogin(String loginType, Object loginId, SaLoginModel loginModel) {
		// ... 
	}

	/** 每次注销时触发 */
	@Override
	public void doLogout(String loginType, Object loginId, String tokenValue) {
		// ... 
	}

	/** 每次被踢下线时触发 */
	@Override
	public void doKickout(String loginType, Object loginId, String tokenValue) {
		// ... 
	}

	/** 每次被顶下线时触发 */
	@Override
	public void doReplaced(String loginType, Object loginId, String tokenValue) {
		// ... 
	}

	/** 每次被封禁时触发 */
	@Override
	public void doDisable(String loginType, Object loginId, long disableTime) {
		// ... 
	}

	/** 每次被解封时触发 */
	@Override
	public void doUntieDisable(String loginType, Object loginId) {
		// ... 
	}

	/** 每次创建Session时触发 */
	@Override
	public void doCreateSession(String id) {
		// ... 
	}

	/** 每次注销Session时触发 */
	@Override
	public void doLogoutSession(String id) {
		// ... 
	}

}

/**
 * [UAAC 权限认证] 配置类 
 */
@Configuration
public class CpTokenConfigure {
	
	/**
	 * 注册 [UAAC全局过滤器] 
	 */
	@Bean
	public CpServletFilter getCpServletFilter() {
        return new CpServletFilter()
		
        		// 指定 拦截路由 与 放行路由
        		.addInclude("/**").addExclude("/favicon.ico")
				
        		// 认证函数: 每次请求执行 
        		.setAuth(obj -> {
					System.out.println("---------- 进入UAAC全局认证 -----------");
					
					// 登录认证 -- 拦截所有路由，并排除/user/doLogin 用于开放登录 
					CpRouter.match("/**", "/user/doLogin", () -> StpUtil.checkLogin());
					
					// 更多拦截处理方式，请参考“路由拦截式鉴权”章节 
        		})
				
        		// 异常处理函数：每次认证函数发生异常时执行此函数 
        		.setError(e -> {
					System.out.println("---------- 进入UAAC异常处理 -----------");
        			return AjaxJson.getError(e.getMessage());
        		})
				
        		// 前置函数：在每次认证函数之前执行
        		.setBeforeAuth(r -> {
        			// ---------- 设置一些安全响应头 ----------
        			CpHolder.getResponse()
        			// 服务器名称 
        			.setServer("uaac-server")
        			// 是否可以在iframe显示视图： DENY=不可以 | SAMEORIGIN=同域下可以 | ALLOW-FROM uri=指定域名下可以 
        			.setHeader("X-Frame-Options", "SAMEORIGIN")
        			// 是否启用浏览器默认XSS防护： 0=禁用 | 1=启用 | 1; mode=block 启用, 并在检查到XSS攻击时，停止渲染页面 
        			.setHeader("X-XSS-Protection", "1; mode=block")
        			// 禁用浏览器内容嗅探 
        			.setHeader("X-Content-Type-Options", "nosniff")
        			;
        		})
        		;
	}
	
}