package com.xlh.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.xlh.pojo.User;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class JWTUtil {
    //token有效时长
    private static final long EXPIRE=30*60*1000L;
    //token的密钥 可自行定义
    private static final String SECRET="jwt";


    public static String createToken(User user) throws UnsupportedEncodingException {
        //token过期时间
        Date date=new Date(System.currentTimeMillis()+EXPIRE);

        //jwt的header部分
        Map<String ,Object>map=new HashMap<>();
        map.put("alg","HS256");
        map.put("typ","JWT");

        //使用jwt的api生成token
        String token= JWT.create()
                .withHeader(map)
                .withClaim("username", user.getUsername())//私有声明
                .withExpiresAt(date)//过期时间
                .withIssuedAt(new Date())//签发时间
                .sign(Algorithm.HMAC256(SECRET));//签名
        return token;
    }

    /**
     * 校验token的有效性
     * 1 token的header和payload是否没改过
     * 2 没有过期
     */
    public static boolean verify(String token){
        try {
            //解密
            JWTVerifier verifier=JWT.require(Algorithm.HMAC256(SECRET)).build();
            verifier.verify(token);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    //无需解密也可以获取token的信息
    public static String getUsername(String token){
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }
}

package com.xlh.Interceptor;
import com.xlh.util.JWTUtil;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class JWTInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  // 判断是否是预检请求，是则直接返回
       if (request.getMethod().equals("OPTIONS")){
            return true;
        }
        //从请求头内获取token
        String token = request.getHeader("Authorization");
        System.out.println("token");
        System.out.println(token);
        //验证令牌  如果令牌不正确会出现异常 被全局异常处理


        return JWTUtil.verify(token);
    }

}

package com.xlh.config;
import com.xlh.Interceptor.JWTInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/user/login");
    }
}

package com.xlh.mapper;
import com.xlh.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;
import java.util.List;
@Mapper
@Repository
public interface LoginMapper {
    @Select("select id,username,password from user where username=#{username}")
    public User getUserByUserName(String username);
}

package com.xlh.service;
import com.xlh.pojo.User;
public interface LoginService {
    public User getUser(String username);
}

package com.xlh.service.impl;
import com.xlh.mapper.LoginMapper;
import com.xlh.pojo.User;
import com.xlh.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private LoginMapper loginMapper;

    @Override
    public User getUser(String username) {
        User user=loginMapper.getUserByUserName(username);
        //未查到用户
        if(user==null){
            return null;
        }
        else{
            return user;
        }
    }
}

package com.xlh.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xlh.common.api.CommonResult;
import com.xlh.pojo.User;
import com.xlh.service.LoginService;
import com.xlh.util.JWTUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
@RestController
@RequestMapping("/user")
@CrossOrigin
public class LoginController {
    @Autowired
    private LoginService loginService;

    @RequestMapping(method = RequestMethod.POST, path="/login")
    @ResponseBody
    public CommonResult login(@RequestBody String requestBody) throws Exception{
        JSONObject jsonObject = JSON.parseObject(requestBody);
        String name=jsonObject.getString("username");
        String password=jsonObject.getString("password");
        User user=loginService.getUser(name);
        System.out.println(user);
        //登录失败
        if(user==null){
            return CommonResult.success(200,"登录失败");
        }
        else{
            if(user.getPassword().equals(password)){
                HashMap<String, String> map=new HashMap<>();
                String token= JWTUtil.createToken(user);
                map.put("token",token);
                return CommonResult.success(200,"登录成功",map);
            }
            else{
                return CommonResult.success(200,"登录失败");
            }
        }
    }

    @RequestMapping(method = RequestMethod.GET,value = "/info")
    @ResponseBody
    public CommonResult info(HttpServletRequest request) {
        String token = request.getHeader("Authorization");
        HashMap<String, String> responseData = new HashMap<>();
        responseData.put("roles","admin");
        String username=JWTUtil.getUsername(token);
        responseData.put("username",username);
        responseData.put("avatar","");
        return CommonResult.success(200,"获取成功",responseData);
    }

    @RequestMapping(method = RequestMethod.POST,value = "/logout")
    @ResponseBody
    public CommonResult logout() {
        return CommonResult.success("ok");
    }
}

public class User {
    @ApiModelProperty(value = "用户名", required = true)
    @NotEmpty(message = "用户名不为空")
    private String username;
    @ApiModelProperty(value = "密码", required = true)
    @NotEmpty(message = "密码不为空")
    private String password;
    @ApiModelProperty(value = "邮箱", required = true)
    @Email(message = "邮箱格式不合法")
    private String email;
    @ApiModelProperty(value = "是否进行显示")
    @FlagValidator(value = {"0","1"}, message = "显示状态不正确")
    private Integer showStatus;
}

@Controller
@RequestMapping("/test")
publicclass TestController {
    @RequestMapping(value = "/t0", method = RequestMethod.POST)
    @ResponseBody
    public T create(@Validated @RequestBody User user, BindingResult result) {
        ...
    }
}

//在controller类的方法中，对参数通过HibernateValidator注解校验，然后利用aop通过此类对校验错误的进行整理输出日志
// 代理
@Aspect
//组件，该类和被代理的类都需要有
@Component
//优先级
@Order(2)
public class BindingResultAspect {
    //切入点为controller所有方法
    @Pointcut("execution(public * cn.xlh.controller.*.*(..))")
    public void BindingResult() {
    }

    //环绕通知
    @Around("BindingResult()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取切入方法的所有参数
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            //参数被HibernateValidator注解校验
            if (arg instanceof BindingResult) {
                //判断是否出错
                ...
            }
        }
        return joinPoint.proceed();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD,ElementType.PARAMETER})
@Constraint(validatedBy = FlagValidatorClass.class)
public @interface FlagValidator {
    String[] value() default {};
    String message() default "flag is not found";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

public class FlagValidatorClass implements ConstraintValidator<FlagValidator,Integer> {
    private String[] values;
    @Override
    public void initialize(FlagValidator flagValidator) {
        this.values = flagValidator.value();
    }

    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext constraintValidatorContext) {
        boolean isValid = false;
        if(value==null){
            //当状态为空时使用默认值
            return true;
        }
        for(int i=0;i<values.length;i++){
            if(values[i].equals(String.valueOf(value))){
                isValid = true;
                break;
            }
        }
        return isValid;
    }
}

public class User {
    @ApiModelProperty(value = "是否进行显示")
    @FlagValidator(value = {"0","1"}, message = "显示状态不正确")
    private Integer showStatus;
}

package com.demo.spsc.config;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    //授权
    //链式编程
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //首页所有人都能访问，功能页只对有权限的用户开放
        //请求授权的规则，角色等
        http.authorizeHttpRequests()
                .antMatchers("/").permitAll()
                .antMatchers("/level1/**").hasRole("vip1")
                .antMatchers("/level2/**").hasRole("vip2")
                .antMatchers("/level3/**").hasRole("vip3");

        //没有权限会默认到登录页，但该页为内部默认登录页，而不是我们自己写的登录页。也可以将该方法用and()拼接到上面的链式编程上
        //可以自定义登录页,前者为前往登录页，后者为登录提交url（与前端对应），参数也需对应，如不对应，也可在下面手动对应
        http.formLogin().loginPage("/toLoginForm").usernameParameter("username").passwordParameter("password").loginProcessingUrl("/login");

        //开启注销功能,注销后跳转到首页
        http.logout().logoutSuccessUrl("/");

        //开启记住我功能,利用cookie默认保存两周,参数也需和前端对应
        http.rememberMe().rememberMeParameter("remember");
    }

    //认证，注意：在springboot2.1以上的版本中，会报错：密码未编码,在下面加入passwordEncoder方法可解决
    //spring5 security5.0+的版本中，新增多种加密算法
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //在内存中进行认证,也可使用jdbc相关方法通过数据库认证
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("xlh").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2")
                .and()
                .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
                .and()
                .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1");
    }
}

package com.demo.spsc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RouterController {
    @RequestMapping({"/","/index"})
    public String index(){
        return "index";
    }

    @RequestMapping("/toLoginForm")
    public String toLogin(){
        return "views/login";
    }

    @RequestMapping("/level1/{id}")
    public String level1(@PathVariable("id") int id){
        return "views/level1/"+id;
    }

    @RequestMapping("/level2/{id}")
    public String level2(@PathVariable("id") int id){
        return "views/level2/"+id;
    }

    @RequestMapping("/level3/{id}")
    public String level3(@PathVariable("id") int id){
        return "views/level3/"+id;
    }
}

public static void main(String[] args) {

        AtomicInteger flag = new AtomicInteger(2);

        Thread c =  new Thread(()->{
            System.out.println("线程C开启，等待线程A、B执行完成才继续执行");
            LockSupport.park();
            System.out.println("线程C开始执行");
        });
        c.start();

        new Thread(()->{
            System.out.println("线程A开始执行");
            try {
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A执行完成");
            if (flag.decrementAndGet() == 0){
            //唤醒指定线程
                LockSupport.unpark(c);
            }
        }).start();
        
        new Thread(()->{
            System.out.println("线程B开始执行");
            try {
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程B执行完成");
            if (flag.decrementAndGet() == 0){
                LockSupport.unpark(c);
            }
        }).start();
    }

public static void main(String[] args) {

        CountDownLatch  latch = new CountDownLatch(2);

        new Thread(() -> {
            System.out.println("线程A开始执行");
            try {
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                latch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程A执行完成");
        }).start();

        new Thread(() -> {
            System.out.println("线程B开始执行");
            try {
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                latch.countDown();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程B执行完成");

        }).start();

        new Thread(() -> {
            System.out.println("线程C开启，等待线程A、B执行完成才继续执行");
            try {
                latch.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程C执行完成");

        }).start();

    }

public static void main(String[] args) {

        CyclicBarrier barrier = new CyclicBarrier(3);

        //只有所有线程执行到了 await()，所有线程才会继续往下执行

        new Thread(() -> {
            System.out.println("线程A开始执行");
            try {
                //执行业务
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                System.out.println("线程A执行完成，等待其它线程一起冲破栅栏");
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程A执行完成");
        }).start();

        new Thread(() -> {
            System.out.println("线程B开始执行");
            try {
                //执行业务
                TimeUnit.SECONDS.sleep(new Random().nextInt(10));
                System.out.println("线程B执行完成，等待其它线程一起冲破栅栏");
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程B执行完成");

        }).start();

        new Thread(() -> {
            try {
                System.out.println("线程C开启，等待线程AB执行完成一起冲破栅栏");
                barrier.await();
                //执行业务
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程C执行完成");

        }).start();

    }

package com.xlh.yygh.oss;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;

//取消数据源自动配置
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableDiscoveryClient
@ComponentScan(basePackages = {"com.xlh"})
public class ServiceOssApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceOssApplication.class, args);
    }
}

package com.xlh.yygh.oss.utils;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConstantOssPropertiesUtils implements InitializingBean {

    @Value("${aliyun.oss.endpoint}")
    private String endpoint;

    @Value("${aliyun.oss.accessKeyId}")
    private String accessKeyId;

    @Value("${aliyun.oss.secret}")
    private String secret;

    @Value("${aliyun.oss.bucket}")
    private String bucket;

    public static String EDNPOINT;
    public static String ACCESS_KEY_ID;
    public static String SECRECT;
    public static String BUCKET;

    @Override
    public void afterPropertiesSet() throws Exception {
        EDNPOINT=endpoint;
        ACCESS_KEY_ID=accessKeyId;
        SECRECT=secret;
        BUCKET=bucket;
    }
}

package com.xlh.yygh.oss.service;

import org.springframework.web.multipart.MultipartFile;

public interface FileService {
    String upload(MultipartFile file);
}

package com.xlh.yygh.oss.service.impl;

import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.xlh.yygh.oss.service.FileService;
import com.xlh.yygh.oss.utils.ConstantOssPropertiesUtils;
import org.joda.time.DateTime;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

@Service
public class FileServiceImpl implements FileService {
    @Override
    public String upload(MultipartFile file) {
        String endpoint = ConstantOssPropertiesUtils.EDNPOINT;
        String accessKeyId = ConstantOssPropertiesUtils.ACCESS_KEY_ID;
        String accessKeySecret = ConstantOssPropertiesUtils.SECRECT;
        String bucketName = ConstantOssPropertiesUtils.BUCKET;
        try {
            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
            // 上传文件流。
            InputStream inputStream = file.getInputStream();
            String fileName = file.getOriginalFilename();
            //生成随机唯一值，使用uuid，添加到文件名称里面
            String uuid = UUID.randomUUID().toString().replaceAll("-","");
            fileName = uuid+fileName;
            //按照当前日期，创建文件夹，上传到创建文件夹里面
            //  2021/02/02/01.jpg
            String timeUrl = new DateTime().toString("yyyy/MM/dd");
            fileName = timeUrl+"/"+fileName;
            //调用方法实现上传
            ossClient.putObject(bucketName, fileName, inputStream);
            // 关闭OSSClient。
            ossClient.shutdown();
            //上传之后文件路径
            // https://yygh-xlh.oss-cn-shanghai.aliyuncs.com/01.jpg
            String url = "https://"+bucketName+"."+endpoint+"/"+fileName;
            //返回
            return url;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

}

package com.xlh.yygh.oss.controller;

import com.xlh.yygh.common.result.Result;
import com.xlh.yygh.oss.service.FileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
@RequestMapping("/api/oss/file")
public class FileApiController {
    @Autowired
    private FileService fileService;

    //上传文件到阿里云oss
    @PostMapping("/fileUpload")
    public Result fileUpload(MultipartFile file) {
        //获取上传文件
        String url = fileService.upload(file);
        return Result.ok(url);
    }
}