@RestController
public class LoginController
{
    @Autowired
    private LoginService loginService;

    @Autowired
    private TokenService tokenService;

    /**
     * 登录方法
     * 
     * @param loginBody 登录信息
     * @return 结果
     */
    @PostMapping("/login")
    public HashMap login(@RequestBody LoginBody loginBody)
    {
        HashMap<String,Object> ajax = new HashMap<>();
        // 生成令牌
        String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(), loginBody.getUuid());
        ajax.put("token", token);
        return ajax;
    }
}

/**
 * 登录校验方法
 */
@Component
public class LoginService
{
    @Autowired
    private TokenService tokenService;

    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 登录验证
     * 
     * @param username 用户名
     * @param password 密码
     * @param code 验证码
     * @param uuid 唯一标识
     * @return 结果
     */
    public String login(String username, String password, String code, String uuid)
    {

        String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
        String captcha = redisTemplate.getStringSerializer(verifyKey);
        redisTemplate.delete(verifyKey);
        if (captcha == null)
        {
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.expire")));
            throw new CaptchaExpireException();
        }
        if (!code.equalsIgnoreCase(captcha))
        {
            AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.jcaptcha.error")));
            throw new CaptchaException();
        }

        // 用户验证
        /*
            用户验证模块自己写，爱怎么写怎么写，数据库里查出来验证也行
        */

        return tokenService.createToken(loginUser);
    }
}

/**
 * token验证处理
 */
@Component
public class TokenService
{
    // 令牌自定义标识
    @Value("${token.header}")
    private String header;

    // 令牌秘钥
    @Value("${token.secret}")
    private String secret;

    // 令牌有效期（默认30分钟）
    @Value("${token.expireTime}")
    private int expireTime;

    protected static final long MILLIS_SECOND = 1000;

    protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;

    private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 从数据声明生成令牌
     *
     * @param claims 数据声明
     * @return 令牌
     */
    private String createToken(Map<String, Object> claims)
    {
        String token = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, secret).compact();
        return token;
    }

    /**
     * 创建令牌
     *
     * @param loginUser 用户信息
     * @return 令牌
     */
    public String createToken(LoginUser loginUser)
    {
        String token = IdUtils.fastUUID();
        loginUser.setToken(token);
        setUserAgent(loginUser);
        refreshToken(loginUser);
        Map<String, Object> claims = new HashMap<>();
        claims.put(Constants.LOGIN_USER_KEY, token);
        return createToken(claims);
    }

    /**
     * 获取用户身份信息
     *
     * @return 用户信息
     */
    public LoginUser getLoginUser(HttpServletRequest request)
    {
        // 获取请求携带的令牌
        String token = getToken(request);
        if (StringUtils.isNotEmpty(token))
        {
            Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
            // 解析对应的权限以及用户信息
            String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
            String userKey = getTokenKey(uuid);
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(userKey);
        }
        return null;
    }

    /**
     * 获取请求token
     *
     * @param request
     * @return token
     */
    private String getToken(HttpServletRequest request)
    {
        String token = request.getHeader(header);
        if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX))
        {
            token = token.replace(Constants.TOKEN_PREFIX, "");
        }
        return token;
    }

    /**
     * 刷新令牌有效期
     *
     * @param loginUser 登录信息
     */
    public void refreshToken(LoginUser loginUser)
    {
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
        // 根据uuid将loginUser缓存
        String userKey = getTokenKey(loginUser.getToken());
        redisTemplate.opsForValue().set(userKey, loginUser, expireTime, TimeUnit.MINUTES);
    }

    /**
     * 验证令牌有效期，相差不足20分钟，自动刷新缓存
     *
     * @param loginUser
     * @return 令牌
     */
    public void verifyToken(LoginUser loginUser)
    {
        long expireTime = loginUser.getExpireTime();
        long currentTime = System.currentTimeMillis();
        if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
        {
            refreshToken(loginUser);
        }
    }
}

/**
 * token过滤器 验证token有效性
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter
{
    @Autowired
    private TokenService tokenService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException
    {
        LoginUser loginUser = tokenService.getLoginUser(request);
        if (StringUtils.isNotNull(loginUser) && StringUtils.isNull(SecurityUtils.getAuthentication()))
        {
            tokenService.verifyToken(loginUser);
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }
        chain.doFilter(request, response);
    }
}

@Component
public class TokenInterceptor implements ClientHttpRequestInterceptor {
 
	@Override
	public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
		HttpHeaders headers = request.getHeaders();
		headers.add("Authorization", "你的token，可以登录时预存在redis里这里取出来");
		return execution.execute(request, body);
	}
}

public interface SomeService {
    void doSome(String name,int age);
    String doOther(String name , int age);
    String doFirst(String name,int age);
    void doSecond(String name,int age);
    void doThird();
}

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String naem,int age) {
        System.out.println("SomeServiceImpl的业务方法doSome");
    }

    @Override
    public String doOther(String name, int age) {
        System.out.println("SomeServiceImpl的业务方法doOther");
        return "abcd";
    }

    @Override
    public String doFirst(String name, int age) {
        System.out.println("SomeServiceImpl的业务方法doFirst");
        return "doFirst";
    }

    @Override
    public void doSecond(String name, int age) {
        System.out.println("SomeServiceImpl的业务方法doSecond");
        int i =10/0;

    }

    @Override
    public void doThird() {
        System.out.println("SomeServiceImpl的业务方法doThird");
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/*
* 切面类：是用来给业务方法增强功能的
* @Aspect：是aspectj框架中的，表示当前类是切面类
*       位置：在类的定义上面使用
* */
@Aspect
public class MyAspect {
    //有功能增强的方法

    /*
    * 定义方法实现功能增强，方法的定义格式
    * 1.public方法
    * 2.一般都是void返回值（环绕通知除外）
    * 3.方法名称自定义
    * 4.方法可以有参数，参数的类型有限制
    * */

    /*
    * @Before:前置通知
    * 属性：value表示切入点表达式，表示切面执行的位置
    * 位置：方法定义的上面
    *
    * 特点：1.在目标方法之前先执行的
    *       2.不会影响目标方法的执行
    *       3.不会改变目标方法的执行结果
    * */
    /*
    * 获取doSome方法在执行时候的信息
    * 参数：JoinPoint表示连接点（业务方法），
    *       连接点是切入点中的一个方法
    * */
    @Before(value = "execution(* com.bjpowernode.service.SomeServiceImpl.doSome(..))")
    public void myBefore(JoinPoint jp){
        //在方法中，实现功能的增强，例如日志代码
        System.out.println("前置通知：在目标方法之前，执行日志的功能");
        //获取方法定义
        System.out.println("连接点的方法定义："+jp.getSignature());
        System.out.println("连接点的方法名称："+jp.getSignature().getName());
        //获取方法执行时的参数
        Object args [] = jp.getArgs();
        for (Object arg : args) {
            System.out.println(arg);
        }
    }

    /*
    * @AfterReturning:后置通知
    *   属性：value：切入点表达式
    *          returning:自定义的变量，表示目标方法的放回值的
    *                    变量的名称必须和通知方法的参数名一样
    *   位置：方法的上面
    * 特点：
    * 1.在目标方法之后执行的
    * 2.能够获取到目标方法的执行结果
    * 3.修改目标方法不会影响最后的执行结果
    * */
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "result")
    public void afterReturing(Object result){
        //修改目标方法返回置
        if(result != null){
            String st = (String)result;
            result = st.toUpperCase();
        }
        System.out.println("后置通知，在目标方法之后执行的。能够获取到目标方法的执行结果:"+result);
    }

    /*
    * @Around:环绕通知
    *   属性：value切入点表达式
    *   位置：方法定义的上面
    * 特点：
    *   1.在目标方法的前和后都能增强功能
    *   2.控制目标方法是否执行
    *   3.修改目标方法的执行结果
    *
    * 环绕通知方法的定义：
    * 1.参数proceedingJoinPoint
    * 2.有返回值，推荐使用object
    * */
    @Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        String name= "";
        Object args [] = pjp.getArgs();
        if(args.length>0){
            name = (String)args[0];
        }
        Object result = null;
        System.out.println("环绕通知：在目标方法之前加入日志");
        //控制目标是否执行
        if("zs".equals(name)){
            //执行目标方法
            result = pjp.proceed();//doFirst result = method.invoke(target,args);
        }
        System.out.println("环绕通知：在目标方法之后加入事务处理");
        //返回目标方法的执行结果（可以是修改后的结果）
        if(result != null){
            result = "Hello Aspectj";
        }
        return result;
    }

    /*
     * @AfterThrowing:异常通知
     *       属性： value:切入点表达式
     *           throwing:自定义的变量，表示目标方法抛出异常现象，必须和通知方法的参数名一样
     *       位置：方法定义的上面
     * 特点：
     * 1.在目标方法抛出异常时执行的，可以看作是对目标方法监控
     * 2.不是异常处理程序，异常还是抛出
     * */
    //@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))", throwing = "ex")
    @AfterThrowing(value = "mypt()",throwing = "ex")
    public void myAfterThrowing(Throwable ex){
        //能够获取异常信息
        //1.把异常记录下来  2.发送通知
        System.out.println("异常通知：在目标方法抛出异常时执行的，异常原因："+ex.getMessage());
    }

    /*
    * @After:最终通知
    *   属性：value切入点表达式
    *   位置：在方法的定义的上面
    * 特点：
    * 1.在目标方法之后执行
    * 2.总是会被执行
    * */
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter(){
        System.out.println("最终通知，总是会被被执行的，可以做收尾工作");
    }

    /*
    * @Pointcut：定义和管理切入点
    *   属性：value切入点表达式
    *   位置：在自定义的方法上面
    * 作用：@Pointcut定义在方法的上面，这个方法的名称就是切入点的别名
    * 其他的通知注解的value属性可以使用方法名称，表示切入点
    * */
    @Pointcut(value = "execution(* *..SomeServiceImpl.doSecond(..))")
    public void mypt(){
        //无需代码
    }
}

public class AppTest {
    @Test
    public void test01(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //从spring的容器中获取目标对象（代理对象）
        SomeService proxy = (SomeService) ctx.getBean("SomeServiceTarget");

        //通过代理对象执行业务方法，实现功能的增强
        proxy.doSome("zhangsan",20);
    }

    @Test
    public void test02(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //从spring的容器中获取目标对象（代理对象）
        SomeService proxy = (SomeService) ctx.getBean("SomeServiceTarget");

        //通过代理对象执行业务方法，实现功能的增强
        String str;
        str = proxy.doOther("zs",21);
        System.out.println("str:"+str);
    }

    @Test
    public void test03(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //从spring的容器中获取目标对象（代理对象）
        SomeService proxy = (SomeService) ctx.getBean("SomeServiceTarget");

        //通过代理对象执行业务方法，实现功能的增强
        String str;
        str = proxy.doFirst("zs",21);
        System.out.println("str:"+str);
    }

    @Test
    public void test04(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //从spring的容器中获取目标对象（代理对象）
        SomeService proxy = (SomeService) ctx.getBean("SomeServiceTarget");

        //通过代理对象执行业务方法，实现功能的增强
        proxy.doSecond("zs",21);
    }

    @Test
    public void test05(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        //从spring的容器中获取目标对象（代理对象）
        SomeService proxy = (SomeService) ctx.getBean("SomeServiceTarget");

        //通过代理对象执行业务方法，实现功能的增强
        proxy.doThird();
    }
}

public class School {
    private String name;
    private String address;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public class Student {
    private String name;
    private int age;

    //引用类型
    private School school;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        System.out.println("setSchool:"+school);
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

public class App {
    public static void main(String[] args){
        //定义spring配置文件
        String config = "applicationContext.xml";
        //创建Spring的容器对象，根据spring配置文件的位置，使用接口的不同实现类
        //如果spring的配置文件是在类路径（classpath），使用ClassPathXmlApplicationContext
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取对象，使用getBean("<bean>的id")
        SomeService student = (SomeService) ctx.getBean("myStudent");
        //输出对象
        System.out.println(student);
    }
}