class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums.length; j++) {
                // 如果找到了，那就保存结果并返回
                if (j != i && nums[j] == target - nums[i]) {
                    return new int[]{i, j};
                }
            }
        }
        // 没有符合要求的两个数
        return new int[]{-1, -1};
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 键为nums[i]
        // 值为索引
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 找到了target-nums[i]
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
            map.put(nums[i], i);
        }
        // 说明没找到
        return new int[]{-1, -1};
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 键为nums[i]
        // 值为索引
        // ==========================
        // 这里手动设置容器初始大小
        // 这样指定初始容量的原因是此map肯定不会放超过nums.length数目的元素，所以就设置默认容量为其正好要扩容的数量+1，就不会扩容了
        // 这里不懂得话，就不写，走默认的容量然后它自己扩容也是可以的
        HashMap<Integer, Integer> map = new HashMap<>((int)((float) nums.length / 0.75F + 1.0F));
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        // ==========================
        for (int i = 0; i < nums.length; i++) {
            // 找到了target-nums[i]
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
            map.put(nums[i], i);
        }
        // 说明没找到
        return new int[]{-1, -1};
    }
}

public class ShiroQuickStart {
    private static final Logger LOG = LoggerFactory.getLogger(ShiroQuickStart.class);
    public static void main(String[] args) {
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);

        Subject currentUser = SecurityUtils.getSubject();
        Session session = currentUser.getSession();
        session.setAttribute("someKey","aValue");
        String value = (String) session.getAttribute("someKey");
        if("aValue".equals(value)){
            LOG.info("Retrieved the correct value");
        }
        if(!currentUser.isAuthenticated()){
            UsernamePasswordToken token = new UsernamePasswordToken("lonestar", "vespa");
            token.setRememberMe(true);
            try{
                currentUser.login(token);
            }catch (UnknownAccountException uae){
                LOG.info("There is no user with username whith "+ token.getPrincipal());
            }catch (IncorrectCredentialsException ice){
                LOG.info("Password for account"+ token.getPrincipal()+"was incorrect");
            }catch (LockedAccountException lae){
                LOG.info("The Account for userName"+ token.getPrincipal()+"is locked. " +
                        "Please contact your administrator to unlocked it");
            }catch (AuthenticationException ae){
                //unexpected exception
            }
        }

        LOG.info("USER["+ currentUser.getPrincipal()+"] logged in successfully");
        if(currentUser.hasRole("schwartz")){
            LOG.info("May the Schwartz be with you");
        }else {
            LOG.info("Hello,Mere mortal");
        }
        
        if(currentUser.isPermitted("lightsaber:wield")){
            LOG.info("You may use a lightsaber ring use it wisely");
        }else {
            LOG.info("Sorry, light rings are for schwartz masters only");
        }
        
        if(currentUser.isPermitted("winnebago:drive:eagle5")){
            LOG.info("You are permitted to 'drive' the winnebago with license plate(id) 'eagle5'. " +
                    "Here are the keys-have fun!");
        }else {
            LOG.info("Sorry,you aren't allowed to drive the 'eagle5' winnebago");
        }
        currentUser.logout();
        System.exit(0);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
    private int id;
    private String userName;
    private String password;
    private String perms;
}

@Configuration
public class ShiroConfig {
    //ShiroFilterFactoryBean
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactory(@Autowired DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }

    //DefaultWebSecurityManager
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Autowired UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    //realm,需要自定义，用来做授权和认证的
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }

public class UserRealm extends AuthorizingRealm {
    @Autowired
    private UserMapper userMapper;
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("授权");
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("认证");
        return null;
    }
}

package com.lizhi.springbootshiro.contoller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class MyController {
    @GetMapping("/index")
    public String index(Model model){
        model.addAttribute("msg","hello,shiro");
        return "index";
    }

    //这里是restful风格
    @GetMapping("/user/{method}")
    public String operateUser(@PathVariable("method") String method){
        return "user/"+method;
    }
}

@Mapper
public interface UserMapper {
    List<User> listAllUsers();
    User getUserByName(String userName);
}

/**
 * anno： 无需认证即可访问
 * authc：必须认证了才可以访问
 * perms：必须拥有权限才可以访问
 * roles：必须拥有某种角色才可以访问
 * user：必须拥有记住我的功能的时候才可以访问（一般很少用）
 */

@Bean
public ShiroFilterFactoryBean getShiroFilterFactory(@Autowired DefaultWebSecurityManager defaultWebSecurityManager){
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
    
    Map<String,String> filterMap = new LinkedHashMap<>();
    filterMap.put("/user/add","perms[user:add]");			//设置该路径只有user:add才可以访问
    filterMap.put("/user/update","perms[user:update]");		//设置该路径只有user:update才可以访问
    filterMap.put("/user/del","perms[user:del]");			//设置该路径只有user:del才可以访问
    filterMap.put("/user/*","authc");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);

    shiroFilterFactoryBean.setLoginUrl("/login");			//设置登录的路径
    shiroFilterFactoryBean.setSuccessUrl("/index");			//设置登录成功的路径
    shiroFilterFactoryBean.setUnauthorizedUrl("/unauth");	//设置未授权的用户被访问后跳转的路径
    return shiroFilterFactoryBean;
}

@GetMapping("/login")
public String login(){
    return "login";
}

@GetMapping("/unauth")
@ResponseBody							//这里偷懒没写页面了，而是直接将消息返回到页面中
public String unauthorized(){
    return "未经授权无法访问此页面";
}
@GetMapping("/login.do")
public String doLogin(String userName, String password, Model model) {
    //获取当前用户
    Subject currentUser = SecurityUtils.getSubject();
    UsernamePasswordToken token = new UsernamePasswordToken(userName, password);
    try{
        currentUser.login(token);//这里下一步是到userRealm的认证方法
        //如果没有抛出异常，则说明登录成功
        Subject currentUser = SecurityUtils.getSubject();
        //拿到shiro内部的session保存数据，
        currentUser.getSession().setAttribute("loginInfo",user);
        return "index";
    }catch (UnknownAccountException uae){
        model.addAttribute("error","用户名错误");
        return "login";
    }catch (IncorrectCredentialsException ice){
        model.addAttribute("error","密码错误");
        return "login";
    }
}

@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("认证");
    /**
     * 数据库中读取数据
     */
    UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    User user = userMapper.getUserByName(token.getUsername());
    if(user==null){
        //这里如果返回null的话，会自动抛出异常到下图处
        return null;
    }
    //这里的第一个参数user会设置给当前登录对象的Principal中。
    //可以通过SecurityUtils.getSubject().getPrincipal()获取
    //第二个参数传入正确的密码，即数据库中的密码，交给shiro来做密码的校验，如果密码错误，也会抛出异常到下图的地方
    return new SimpleAuthenticationInfo(user, user.getPassword(),"");
}

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("授权");
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //这里需要根据用户表的数据进行增加权限
    Subject subject = SecurityUtils.getSubject();
    //拿到用户认证的时候传入的user
    User currentUser = (User) subject.getPrincipal();
    System.out.println("权限为："+ currentUser.getPerms());
    //数据库中perms字段是以这样的形式存储的   user:add,user:update
    //所以需要将其用，分割然后使用工具类将其转换为集合传入addStringPermissions
    info.addStringPermissions(Arrays.asList(currentUser.getPerms().split(",")));
    return info;
}

//整合thymeleaf
@Bean
public ShiroDialect shiroDialect(){
    return new ShiroDialect();
}

@GetMapping("/logout")
public String logout(){
    SecurityUtils.getSubject().logout();
    return "index";
}

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello(){
        return "hello";
    }
}

@Configuration
@EnableSwagger2
public class SwaggerConfig {   
}

@Bean
public Docket docket(){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo());
}
//配置swagger信息
public ApiInfo apiInfo(){
    return new ApiInfo(
            "swagger测试",//文档名称
            "初次测试swagger",//文档描述
            "1.0",//版本号
            "http://li-zhi.net.cn/",//作者个人博客
            new Contact("李智","http://li-zhi.net.cn/","1158778689@qq.com"),//作者联系方式
            "Apache 2.0",//开源协议
            "http://www.apache.org/licenses/LICENSE-2.0",
            new ArrayList<>()
    );
}

@Controller
public class SwaggerModelConfig {
    @GetMapping("/user")
    public User user(){
        return new User();
    }
}

@Bean
public Docket docket2(){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo()).groupName("group2");
}
@Bean
public Docket docket1(){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo()).groupName("group1");
}

@Bean
public Docket docket1(){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo()).groupName("group1")
            .select()
            .paths(PathSelectors.ant("/user/**"))
			// 该配置下，该组会扫描所有的/user/下的所有的API
            .build();
}

@Bean
public Docket docket2(){
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo()).groupName("group2")
            .select()
            .apis(RequestHandlerSelectors.basePackage("com.lizhiswaggertest.controller"))
			//该配置下，该组会扫描所有此包下的API接口
            .build();
}

@Bean
public Docket docket1(Environment environment){
    Profiles devProfile = Profiles.of("dev","test");
    boolean dev = environment.acceptsProfiles(devProfile);
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo()).groupName("group1")
            .enable(dev);
}

public class Hungry {
    private final static Hungry HUNGRY = new Hungry();
    private Hungry(){

    }
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

public class LazyMan {
    private static LazyMan lAZYMAN;
    private LazyMan(){

    }
    public static LazyMan getInstance(){
        if(lAZYMAN==null){
            //A
            lAZYMAN = new LazyMan();
        }
        return lAZYMAN;
    }
}

public class LazyMan {
    private static LazyMan LAZYMAN;
    private LazyMan(){

    }
    public synchronized static LazyMan getInstance(){
        if(LAZYMAN==null){
            LAZYMAN = new LazyMan();
        }
        return LAZYMAN;
    }
}

public class LazyMan {
    private static LazyMan LAZYMAN;
    private LazyMan(){

    }
    public static LazyMan getInstance(){
        if(LAZYMAN==null){
            //A
            synchronized (LazyMan.class){
                LAZYMAN = new LazyMan();
            }
        }
        return LAZYMAN;
    }
}

public class LazyMan {
    private volatile static LazyMan LAZYMAN;
    private LazyMan(){
    
    }
	public static LazyMan getInstance(){
        if(LAZYMAN==null){
            //A
            synchronized (LazyMan.class){
                if(LAZYMAN==null){
                    //B
                    LAZYMAN = new LazyMan();
                }
            }
        }
        return LAZYMAN;
    }
}

public class StaticWay {
    private StaticWay(){

    }
    public static class InnerClass{
        private static final StaticWay STATICWAY = new StaticWay();
    }
    public static StaticWay getInstance(){
        return InnerClass.STATICWAY;
    }
}