springboot第56集：微服务框架，物联网IOT，SQL数据库MySQL底层，AOP收集业务操作日志架构周刊...

/*请求登陆的方法*/
"/modelLogin": {
  //本地服务接口地址，这是测试环境，正式环境需要更改下地址
  target: "http://127.0.0.1:6776/xxx-auth/",
  changeOrigin: true,
  pathRewrite: {
    "^/modelLogin": "",
  },
},


//异步进行登录
this.$store.dispatch("LoginPrammeSystem", loginForm).then(() => {
  //跳转到指定连接（正式环境需要更改地址）
   window.open("http://localhost:1889/");
});

1. /:根目录，与开机系统有关
2. /usr(unix software resource):与软件的安装和执行有关
3. /var(variable):与系统的运作有关

# 进入tmp目录
 cd /tmp/
 
 # 创建testDir文件夹
mkdir testDir

# 设置这个文件夹 所属者有所有权限 所属组和其他用户只有读和写权限
chmod 766 testDir/

<!--SpringSecurity依赖配置-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!--JWT(Json Web Token)登录支持-->
<dependency>
 <groupId>io.jsonwebtoken</groupId>
 <artifactId>jjwt</artifactId>
 <version>0.9.0</version>
</dependency>

jwt:
  tokenHeader: X-Token #JWT存储的请求头
  tokenHead: Bearer  #令牌前缀
  secret: xx-admin-secret #JWT加解密使用的密钥
  expiration: 604800 #JWT的超期限时间秒(60*60*24)

@Slf4j
@Component
public class JwtTokenUtil {

    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expire;


    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username =  claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }
    /**
     * 校验token
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 根据用户信息生成token
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 判断token是否已经失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getClaimsFromToken(token).getExpiration();
        return expiredDate.before(new Date());
    }

    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                //签名算法
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 生成token的过期时间
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expire * 1000);
    }

    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            log.info("JWT格式验证失败:{}",token);
        }
        return claims;
    }
}

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled=true)
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private CustomAccessDeniedHandler customAccessDeniedHandler;
    @Autowired
    private CustomAuthenticationEntryPoint customAuthenticationEntryPoint;
    @Autowired
    private XlUserService xlUserService;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf().disable()// 由于使用的是JWT，我们这里不需要csrf
                .sessionManagement()// 基于token，所以不需要session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 允许对于网站静态资源的无授权访问
                .antMatchers(HttpMethod.GET,
                        "/",
                        "/*.html",
                        "/favicon.ico",
                        "/**/*.html",
                        "/**/*.css",
                        "/**/*.js",
                        "/swagger-resources/**",
                        "/v2/api-docs/**"
                )
                .permitAll()
                // 对登录注册要允许匿名访问
                .antMatchers("/ucenter/xl-user/login", "/ucenter/xl-user/register")
                .permitAll()
                //跨域请求会先进行一次options请求
                .antMatchers(HttpMethod.OPTIONS)
                .permitAll()
                .anyRequest()// 除上面外的所有请求全部需要鉴权认证
                .authenticated();
        // 禁用缓存
        httpSecurity.headers().cacheControl();
        // 添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(customAccessDeniedHandler)
                .authenticationEntryPoint(customAuthenticationEntryPoint);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    @Override
    public UserDetailsService userDetailsService() {
        //获取登录用户信息
        return username -> {
            XlUser user = xlUserService.getUserByCode(username);
            if (user != null) {
                List<XlResource> permissionList = xlUserService.getResourceList(user.getUserId());
                return new JwtUser(user,permissionList);
            }
            throw new UsernameNotFoundException("用户名或密码错误");
        };
    }

    /**
     * 装载BCrypt密码编码器
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * JWT filter
     */
    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
        return new JwtAuthenticationTokenFilter();
    }
}

@Slf4j
@Service
public class XlUserServiceImpl extends ServiceImpl<XlUserMapper, XlUser> implements XlUserService {

    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;


    @Override
    public XlUser register(XlUser user) {
        XlUser newXlUser = new XlUser();
        BeanUtils.copyProperties(user, newXlUser);
        //查询是否有相同用户名的用户
        List<XlUser> xlUsers = this.baseMapper.selectList(new LambdaQueryWrapper<XlUser>().eq(XlUser::getUserCode,newXlUser.getUserCode()));
        if (CollectionUtil.isNotEmpty(xlUsers)) {
            return null;
        }
        //将密码进行加密操作
        String encodePassword = passwordEncoder.encode(user.getPassWord());
        newXlUser.setPassWord(encodePassword);
        this.baseMapper.insert(newXlUser);
        return newXlUser;
    }

    @Override
    public String login(String username, String password) {
        String token = null;
        try {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            if (!passwordEncoder.matches(password, userDetails.getPassword())) {
                throw new BadCredentialsException("密码不正确");
            }
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authentication);
            token = jwtTokenUtil.generateToken(userDetails);
        } catch (AuthenticationException e) {
            log.warn("登录异常:{}", e.getMessage());
        }
        return token;
    }

    @Override
    public List<XlResource> getResourceList(Long userId) {
        return this.baseMapper.getResourceList(userId);
    }

@PreAuthorize("hasAuthority('read')")
@ApiOperation("获取用户所有可访问的资源")

//1
create index idx_username on sys_user(user_name(32));

// 2
alter table sys_user add index idx_username(user_name(32));

create table `sys_user` (
 `id` int(11) not null auto_increment,
 `user_name` varchar(32) default null,
 `pass_word` varchar(32) default null,
 `token` varchar(32) default null,
 `yn` smalliint(6) default null,
 primary key (`id`)
) engine=InnoDB auto_increment=348007 default charset=utf8;

alter table sys_user add index idx_un_te (user_name(32), token_expire);

CREATE FULLTEXT INDEX idx_ ON sys_user(pass_word)

explain select * from sys_user where token_expire = 10000;

@Autowired
private MqttGatewayComponent mqttGatewayComponent;

//发送字符串或json字符串,到指定的topic
mqttGatewayComponent.sendToMqtt("json string", "data/abcd");

/**
 * @desc MQTT发送网关
 */
@Component
@MessagingGateway(defaultRequestChannel = "mqttOutboundChannel")
public interface MqttGatewayComponent {

    void sendToMqtt(String data);

    void sendToMqtt(String payload, @Header(MqttHeaders.TOPIC) String topic);

    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, String payload);

}

// 通过通道获取数据 订阅的数据
// 配置监听的 topic 支持通配符
// 发送通道配置 默认主题

@Bean
public MqttConnectOptions getMqttConnectOptions(){
    // MQTT的连接设置
    MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
    // 设置连接的用户名
    mqttConnectOptions.setUserName(username);
    // 设置连接的密码
    mqttConnectOptions.setPassword(password.toCharArray());
    // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，
    // 把配置里的 cleanSession 设为false，客户端掉线后 服务器端不会清除session，
    // 当重连后可以接收之前订阅主题的消息。当客户端上线后会接受到它离线的这段时间的消息
    mqttConnectOptions.setCleanSession(true);
    // 设置发布端地址,多个用逗号分隔, 如:tcp://111:1883,tcp://222:1883
    // 当第一个111连接上后,222不会在连,如果111挂掉后,重试连111几次失败后,会自动去连接222
    mqttConnectOptions.setServerURIs(hostUrl.split(","));
    // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制
    mqttConnectOptions.setKeepAliveInterval(20);
    mqttConnectOptions.setAutomaticReconnect(true);
    // 设置“遗嘱”消息的话题，若客户端与服务器之间的连接意外中断，服务器将发布客户端的“遗嘱”消息。
    mqttConnectOptions.setWill(willTopic, willContent.getBytes(), 2, false);
    mqttConnectOptions.setMaxInflight(1000000);
    return mqttConnectOptions;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Loggable {
    String value() default "";
    // 可以添加更多的配置属性，如操作类型、级别等
}

@Aspect
@Component
public class LoggingAspect {

    @Around("@annotation(loggable)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
        long start = System.currentTimeMillis();
        
        Object proceed = joinPoint.proceed(); // 执行目标方法

        long executionTime = System.currentTimeMillis() - start;
        
        // 记录日志的逻辑
        logger.info(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        
        return proceed;
    }
}

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {
    // 可能还需要其他的配置或Bean定义
}

public class SomeService {
    
    @Loggable
    public void someBusinessMethod(Object someParam) {
        // 业务逻辑
    }
}

@Autowired
private Logger logger; // 例如，通过SLF4J获取的Logger

@Around("@annotation(loggable)")
public Object logBusinessOperation(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
    // 方法执行前的逻辑，例如记录开始时间、方法参数等
    long start = System.currentTimeMillis();
    try {
        Object result = joinPoint.proceed(); // 执行目标方法
        // 方法执行后的逻辑，例如记录结束时间、返回值等
        return result;
    } catch (Exception e) {
        // 异常处理逻辑，如记录异常信息
        throw e;
    } finally {
        long executionTime = System.currentTimeMillis() - start;
        // 构建日志信息并记录
        logger.info("{} executed in {} ms", joinPoint.getSignature(), executionTime);
    }
}

@Repeatable(LogRecords.class)
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface LogRecord {
    String success();

    String fail() default "";

    String operator() default ""; //业务操作场景人

    String type(); // 业务场景 模块范围

    String subType() default ""; //业务子场景，主要是模块下的功能范围

    String bizNo(); //业务场景的业务编号，

    String extra() default "";//一些操作的扩展操作

    String actionType(); //业务操作类型，比如编辑、新增、删除
}

// 创建数据库连接
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/easyflow", "root", "12345678");
// 自动提交设置
connection.setAutoCommit(false);
// 只读设置
connection.setReadOnly(false);
// 事务隔离级别设置
connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
// 创建查询语句
PreparedStatement statement = connection.prepareStatement("update config set cfg_value='1' where id=11111");
// 执行SQL
int num = statement.executeUpdate();
System.out.println("更新行数:" + num);
// 事务提交
connection.commit();