xml复制代码    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
    </dependencies>

java复制代码@SpringBootApplication
@MapperScan(value = {"cn.soboys.kmall.mapper","cn.soboys.kmall.sys.mapper","cn.soboys.kmall.security.mapper"},nameGenerator = UniqueNameGenerator.class)
@ComponentScan(value =  {"cn.soboys.kmall"},nameGenerator = UniqueNameGenerator.class)
@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
public class WebApplication {
    private static ApplicationContext applicationContext;

    public static void main(String[] args) {
        applicationContext =
                SpringApplication.run(WebApplication.class, args);
        //displayAllBeans();
    }


    /**
     * 打印所以装载的bean
     */
    public static void displayAllBeans() {
        String[] allBeanNames = applicationContext.getBeanDefinitionNames();
        for (String beanName : allBeanNames) {
            System.out.println(beanName);
        }
    }
}

java复制代码/**
 * @author kenx
 * @version 1.0
 * @date 2021/8/17 15:05
 * @webSite https://www.soboys.cn/
 * 自定义缓存配置
 */
@Configuration
@Slf4j
@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
public class CacheConfig {

    //自定义配置类配置keyGenerator

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString() +"]";
            }
        };
    }
}

java复制代码@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
public interface IMenuService extends IService<Menu> {
    /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    @Cacheable(key = "#username")
    List<Menu> getUserMenus(String username);
}

java复制代码@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Cacheable {
    @AliasFor("cacheNames")
    String[] value() default {};

    @AliasFor("value")
    String[] cacheNames() default {};

    String key() default "";

    String keyGenerator() default "";

    String cacheManager() default "";

    String cacheResolver() default "";

    String condition() default "";

    String unless() default "";

    boolean sync() default false;
}

ini复制代码condition = "#id>0"
condition = "#a0>1"：第一个参数的值》1的时候才进行缓存

ini复制代码unless = "#result == null"
unless = "#a0==2":如果第一个参数的值是2，结果不缓存；

java复制代码 /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    @Cacheable(cacheNames = "menuCache") 或者// @Cacheable(cacheNames = {"menuCache","neCacge"})
    List<Menu> getUserMenus(String username);

java复制代码//key = "#username" 就是参数username
 @Cacheable(key = "#username" ,cacheNames = "menuCache")
List<Menu> getUserMenus(String username);

java复制代码@Configuration
@Slf4j
@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
public class CacheConfig {

    //自定义配置类配置keyGenerator

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString() +"]";
            }
        };
    }
}

java复制代码 /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    //判断username 用户名是kenx开头才会被缓存
    @Cacheable(key = "#username" ,condition = "#username.startsWith('kenx')")
    List<Menu> getUserMenus(String username);

java复制代码 /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    //判断username 用户名是kenx开头不会被缓存
    @Cacheable(key = "#username" ,condition = "#username.startsWith('kenx')")
    List<Menu> getUserMenus(String username);

java复制代码//全局配置，下面用到缓存方法，不配置默认使用全局的
@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
public interface IMenuService extends IService<Menu> {
    /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    @Cacheabl
    List<Menu> getUserMenus(String username);
}

java复制代码@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CachePut {
    @AliasFor("cacheNames")
    String[] value() default {};

    @AliasFor("value")
    String[] cacheNames() default {};

    String key() default "";

    String keyGenerator() default "";

    String cacheManager() default "";

    String cacheResolver() default "";

    String condition() default "";

    String unless() default "";
}

java复制代码/**
     *  @CachePut：既调用方法，又更新缓存数据；同步更新缓存
     *  修改了数据，同时更新缓存
     */
    @CachePut(value = {"emp"}, key = "#result.id")
    public Employee updateEmp(Employee employee){
        employeeMapper.updateEmp(employee);
        LOG.info("更新{}号员工数据",employee.getId());
        return employee;
    }

java复制代码@CacheEvict(value = {"emp"}, beforeInvocation = true,key="#id")
    public void deleteEmp(Integer id){
        employeeMapper.deleteEmpById(id);
        //int i = 10/0;
    }

java复制代码// @Caching 定义复杂的缓存规则
    @Caching(
            cacheable = {
                    @Cacheable(/*value={"emp"},*/key = "#lastName")
            },
            put = {
                    @CachePut(/*value={"emp"},*/key = "#result.id"),
                    @CachePut(/*value={"emp"},*/key = "#result.email")
            }
    )
    public Employee getEmpByLastName(String lastName){
        return employeeMapper.getEmpByLastName(lastName);
    }

java复制代码//全局配置，下面用到缓存方法，不配置默认使用全局的
@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
public interface IMenuService extends IService<Menu> {
    /**
     * 获取用户菜单信息
     *
     * @param username 用户名
     * @return
     */
    @Cacheable(key = "#username" )
    List<Menu> getUserMenus(String username);
}

sql复制代码CREATE TABLE test_table (
  id bigint(20) UNSIGNED NOT NULL AUTO_INCREMENT,
  name varchar(32) NOT NULL,
  PRIMARY KEY (id)
) ENGINE = InnoDB CHARSET = utf8mb4;

sql复制代码EXPLAIN SELECT COUNT(*)FROM test_tableWHERE id >= 10534	AND id <= 15375;

sql复制代码EXPLAIN SELECT COUNT(*)FROM test_tableWHERE id >= 10000	LIMIT 10;

sql复制代码文件1：sql/opt_explain_traditional.cc   
   关键部分：push(&items, column_buffer.col_rows, nil)

文件2：sql/opt_explain.cc
   关键部分：select->quick->records

文件3：sql/opt_range.cc
   关键部分：check_quick_select

scss复制代码findOrder(OrderId id);//获取完整的order聚合

findOrderWithoutItems(OrderId id);//只取order不取明细

xml复制代码<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.6</version>
</dependency>
<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.10.2</version>
</dependency>

ini复制代码public class MusicSpider {


    private String downloadUrl = "http://music.163.com/song/media/outer/url?id=";

    private String path = "D:/music/";

    /**
     * 获取歌曲列表
     * @param url
     */
    public void getSongList(String url) {
        Document document = getHtml(url);
        if (document != null) {
            Elements elements = document.select("#song-list-pre-data");
            System.out.println("json数据如下" + elements.text());
            String resJson = elements.text();  //解析歌曲列表
            JSONArray jsonArray = JSONObject.parseArray(resJson);
            //遍历获取歌曲信息
            for (int i = 0; i < jsonArray.size(); i++) {
                Music music = new Music();
                String singer = jsonArray.getJSONObject(i).getJSONArray("artists").getJSONObject(0).get("name").toString();
                music.setSinger(singer);
                music.setSongUrl(downloadUrl + jsonArray.getJSONObject(i).get("id").toString());
                music.setSong(jsonArray.getJSONObject(i).get("name").toString());
                try {
                    if(i<jsonArray.size()){
                        Thread.sleep(10000);
                        System.out.println("休息10秒继续爬  ");
                        downloadFile(music.getSongUrl(), path + music.getSong() + "-" + music.getSinger() + ".mp3");
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }


    /**
     * 下载文件
     * @param fileUrl       文件地址
     * @param fileLocal     文件保存地址
     * @throws Exception
     */
    public void downloadFile(String fileUrl, String fileLocal) throws Exception {
        URL url = new URL(fileUrl);
        HttpURLConnection urlCon = (HttpURLConnection) url.openConnection();
        urlCon.setConnectTimeout(6000);
        urlCon.setReadTimeout(6000);
        int code = urlCon.getResponseCode();
        if (code != HttpURLConnection.HTTP_OK) {
            throw new Exception("文件读取失败");
        }

        //读文件流；
        DataInputStream in = new DataInputStream(urlCon.getInputStream());
        DataOutputStream out = new DataOutputStream(new FileOutputStream(fileLocal));
        byte[] buffer = new byte[2048];
        int count = 0;
        while ((count = in.read(buffer)) > 0) {
            out.write(buffer, 0, count);
        }
        out.close();
        in.close();

    }

    /**
     * 获得页面
     * @param url
     * @return
     */
    private Document getHtml(String url) {
        List<Header> headerList = new ArrayList<>();
        headerList.add(new BasicHeader("origin", "music.163.com"));
        headerList.add(new BasicHeader("referer", "https://music.163.com/"));
        headerList.add(new BasicHeader("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36"));
        headerList.add(new BasicHeader("cookie", "这里是储存你登录的cookie"));
        String result = HttpClientUtil.doGet(url, headerList, "utf-8");
        if (result != null && !result.contains("n-for404")) {
            return Jsoup.parse(result);
        }
        return null;
    }

}

arduino复制代码@Data
public class Music {

    private String singer;

    private String song;

    private String songUrl;

    public Music(){

    }

    public Music(String singer,String song,String songUrl){
        this.singer = singer;
        this.song = song;
        this.songUrl =songUrl;
    }
}

typescript复制代码 public static void main(String[] args){
        MusicSpider spider = new MusicSpider();
        //这里需要自己手动更改歌手的id  ，不知道为什么拿不到排行榜的数据，暂时先这样，以后如果解决了再修改
        spider.getSongList("https://music.163.com/artist?id=3684");
}

java复制代码C- EurekaDiscoveryClientConfiguration
public EurekaDiscoveryClient discoveryClient(EurekaClient client,
      EurekaClientConfig clientConfig) {
   return new EurekaDiscoveryClient(client, clientConfig);
}

C- EurekaClientAutoConfiguration

jAVA复制代码C- EurekaServiceRegistry
    M- register : 注册应用 
    M- deregister
    M- setStatus : 更新状态
    M- getStatus

java复制代码// C- EurekaServiceRegistry
public void start() {
   // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
   if (this.port.get() != 0) {
      if (this.registration.getNonSecurePort() == 0) {
         this.registration.setNonSecurePort(this.port.get());
      }

      if (this.registration.getSecurePort() == 0 && this.registration.isSecure()) {
         this.registration.setSecurePort(this.port.get());
      }
   }

   // 只有在nonSecurePort大于0且由于下面的containerPortInitializer未运行时才初始化
   if (!this.running.get() && this.registration.getNonSecurePort() > 0) {
      // 2.1.1 -> 发起注册逻辑
      this.serviceRegistry.register(this.registration);
      // 发出 InstanceRegisteredEvent 事件  
      this.context.publishEvent(new InstanceRegisteredEvent<>(this,
            this.registration.getInstanceConfig()));
      this.running.set(true);
   }
}

java复制代码// Start 方法基于 Lifecycle 接口 , 这个接口用于控制Bean 的生命周期 ,当 Application 发生 开启和停止时 , 都会调用对应的钩子事件
public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

java复制代码// C- EurekaServiceRegistry
public void register(EurekaRegistration reg) {
   maybeInitializeClient(reg);
    
   // 通过修改状态发起注册逻辑
   // PS : deregister 就是设置为 InstanceInfo.InstanceStatus.DOWN
   reg.getApplicationInfoManager()
         .setInstanceStatus(reg.getInstanceConfig().getInitialStatus());
    
   // 健康检查 ,此处暂时不深入 
   reg.getHealthCheckHandler().ifAvailable(healthCheckHandler -> reg
         .getEurekaClient().registerHealthCheck(healthCheckHandler));
}

java复制代码C- EurekaServiceRegistry
public synchronized void setInstanceStatus(InstanceStatus status) {
    // InstanceStatus.UP
    InstanceStatus next = instanceStatusMapper.map(status);
    if (next == null) {
        return;
    }

    InstanceStatus prev = instanceInfo.setStatus(next);
    if (prev != null) {
        for (StatusChangeListener listener : listeners.values()) {
                // 可以看到 , 通过调用监听器发送状态改变的事件 -> Step 3 
                listener.notify(new StatusChangeEvent(prev, next));
        }
    }
}

// 补充 : StatusChangeListener 对象
public static interface StatusChangeListener {
    String getId();
    void notify(StatusChangeEvent statusChangeEvent);
}

// 补充 : StatusChangeEvent 对象
public class StatusChangeEvent extends DiscoveryEvent {
    // 这个对象中记录了2个状态 , 之前和现在的, 但是这个好像只是为了打印日志 , 也没啥区别 TODO
    private final InstanceInfo.InstanceStatus current;
    private final InstanceInfo.InstanceStatus previous;
}

java复制代码C- InstanceInfoReplicator
public boolean onDemandUpdate() {
    if (rateLimiter.acquire(burstSize, allowedRatePerMinute)) {
            // 省略不必要的关注点 , 可以看到这里通过 ScheduledExecutorService 发起了定时任务
            scheduler.submit(new Runnable() {
                @Override
                public void run() {
                    // private final AtomicReference<Future> scheduledPeriodicRef;
                    Future latestPeriodic = scheduledPeriodicRef.get();
                    if (latestPeriodic != null && !latestPeriodic.isDone()) {
                        latestPeriodic.cancel(false);
                    }
                    // 更新本地实例信息并复制到远程服务器 -> Step 4
                    InstanceInfoReplicator.this.run();
                }
            });

    }
}

java复制代码public void run() {
    try {
        // 刷新当前本地InstanceInfo , InstanceInfo上的isdirty标志被设置为true
        discoveryClient.refreshInstanceInfo();

        Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
        if (dirtyTimestamp != null) {
            // 最核心的一句 : 发起服务注册
            discoveryClient.register();
            // 如果unsetDirtyTimestamp 匹配 lastDirtyTimestamp，则取消dirty标志
            instanceInfo.unsetIsDirty(dirtyTimestamp);
        }
    } catch (Throwable t) {
    } finally {
        Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
        scheduledPeriodicRef.set(next);
    }
}

java复制代码C- DiscoveryClient
boolean register() throws Throwable {
    EurekaHttpResponse<Void> httpResponse;
    try {
        // 发起注册逻辑
        httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
    } catch (Exception e) {
        throw e;
    }
    // 这个返回在业务上没有太大的作用
    return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
}

JAVA复制代码// 这里和下方的模式非常相似 ,都是传个匿名函数进去 , 再由里面发起回调
C- EurekaHttpClientDecorator
public EurekaHttpResponse<Void> register(final InstanceInfo info) {
    return execute(new RequestExecutor<Void>() {
        @Override
        public EurekaHttpResponse<Void> execute(EurekaHttpClient delegate) {
            // 通过该回调函数进行链式调用
            return delegate.register(info);
        }

        @Override
        public RequestType getRequestType() {
            return RequestType.Register;
        }
    });
}

java复制代码// 通常内部是通过 clientFactory 构建下一个 HttpClient  , 这个对象在 EurekaHttpClients 中通过构造器传入
TransportUtils.getOrSetAnotherClient(eurekaHttpClientRef, clientFactory.newClient());


// 这几个里面有几个关注点 : 
// 关注点一 : 原子对象类
private final AtomicReference<EurekaHttpClient> eurekaHttpClientRef = new AtomicReference<>();

java复制代码C- MetricsCollectingEurekaHttpClient
protected <R> EurekaHttpResponse<R> execute(RequestExecutor<R> requestExecutor) {
    EurekaHttpClientRequestMetrics requestMetrics = metricsByRequestType.get(requestExecutor.getRequestType());
    // 度量执行某些代码所花费的时间
    Stopwatch stopwatch = requestMetrics.latencyTimer.start();
    try {
        // HttpClient 中最常见的模式就说这种匿名类的回调
        EurekaHttpResponse<R> httpResponse = requestExecutor.execute(delegate);
        requestMetrics.countersByStatus.get(mappedStatus(httpResponse)).increment();
        return httpResponse;
    } catch (Exception e) {
        requestMetrics.connectionErrors.increment();
        exceptionsMetric.count(e);
        throw e;
    } finally {
        // 计时结束
        stopwatch.stop();
    }
}

java复制代码// Step 1 : JerseyEurekaHttpClientFactory 的创建
public TransportClientFactory newTransportClientFactory(EurekaClientConfig clientConfig,
        Collection<ClientFilter> additionalFilters, InstanceInfo myInstanceInfo, Optional<SSLContext> sslContext,
        Optional<HostnameVerifier> hostnameVerifier) {
    final TransportClientFactory jerseyFactory = JerseyEurekaHttpClientFactory.create(
            clientConfig,
            additionalFilters,
            myInstanceInfo,
            new EurekaClientIdentity(myInstanceInfo.getIPAddr()),
            sslContext,
            hostnameVerifier
    );
    
    // 通过工厂创建
    final TransportClientFactory metricsFactory = MetricsCollectingEurekaHttpClient.createFactory(jerseyFactory);

    return new TransportClientFactory() {
        @Override
        public EurekaHttpClient newClient(EurekaEndpoint serviceUrl) {
            // 匿名对象回调函数
            return metricsFactory.newClient(serviceUrl);
        }
    };
}

// Step 2 : 构造器注入
private MetricsCollectingEurekaHttpClient(EurekaHttpClient delegate,
                                          Map<RequestType, EurekaHttpClientRequestMetrics> metricsByRequestType,
                                          ExceptionsMetric exceptionsMetric,
                                          boolean shutdownMetrics) {
    ....

java复制代码// C- AbstractJerseyEurekaHttpClient
public EurekaHttpResponse<Void> register(InstanceInfo info) {
    // http://localhost:8088/eureka/
    String urlPath = "apps/" + info.getAppName();
    ClientResponse response = null;
    try {
        // 准备 Build 用于构造 Request
        // serviceUrl -> http://localhost:8088/eureka/
        Builder resourceBuilder = jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder();
        addExtraHeaders(resourceBuilder);
            
        // 发起请求 , 此处使用的是 jersey 
        response = resourceBuilder
                .header("Accept-Encoding", "gzip")
                .type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON)
                .post(ClientResponse.class, info);
        return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
    } finally {
        if (response != null) {
            response.close();
        }
    }
}

xml复制代码 <!--    mybatis-plus    -->
     <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!--    mybatis-plus    -->

yaml复制代码spring:
  datasource:
    url: jdbc:p6spy:mysql://127.0.0.1:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
    username: admin
    password: 123456
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    
mybatis-plus:
  global-config:
    db-config:
      db-type: mysql
      id-type: AUTO
      logic-delete-field: dataState  
      logic-delete-value: 0
      logic-not-delete-value: 1 
    banner: false
  mapper-locations: classpath*:mapper/**/*.xml
  typeAliasesPackage: java.zhan.entity
  typeEnumsPackage: java.zhan.enums;java.zhan.test.enums

less复制代码@EnableTransactionManagement
@Configuration
@MapperScan("java.zhan.**.mapper")
public class MybatisPlusConfig {

    // 旧版
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
    
    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
    
}

less复制代码@SpringBootApplication
@MapperScan(value = "com.example.demo.mapper")
public class DemoMybatisPlusApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoMybatisPlusApplication.class, args);
    }

}

typescript复制代码    /**
     * @MethodName: insertUser
     * @Description: 新增
     * @param 
     * @Return: void
     * @Author: JavaZhan @公众号:Java全栈架构师
     * @Date: 2020/6/20
     **/
    @Test
    void insertUser(){
        User user = new User();
        user.setUsername("gust");
        user.setName("测试");
        user.setCreatetime(new Date());
        user.setSalt(1+"");
        user.setPassword("1233123");
        user.setState(0);
        userService.save(user);
    }
    
    
    /**
     * @MethodName: getUserByUserName
     * @Description: 获取单个对象
     * @param 
     * @Return: void
     * @Author: JavaZhan @公众号:Java全栈架构师
     * @Date: 2020/6/20
     **/
    @Test
    void getUserByUserName() {
        QueryWrapper<User> quserQueryWrapper = new QueryWrapper<>();
        quserQueryWrapper.lambda().eq(User::getUserName,"admin");
        User user = userService.getOne(quserQueryWrapper);
        System.out.println(user);
    }

    /**
     * @MethodName: getAllUser
     * @Description: 获取所有的用户
     * @param
     * @Return: void
     * @Author: JavaZhan @公众号:Java全栈架构师
     * @Date: 2020/6/20
     **/
    @Test
    void getAllUser(){
        List<User> userList = userService.list();
        userList.forEach(user -> System.out.println(user));
    }

ini复制代码public class SocketServer {
  public static void main(String[] args) throws Exception {
    // 监听指定的端口
    int port = 8080;
    ServerSocket server = new ServerSocket(port);
    // server将一直等待连接的到来
    Socket socket = server.accept();
    // 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
    InputStream inputStream = socket.getInputStream();
    byte[] bytes = new byte[1024];
    int len;
    while ((len = inputStream.read(bytes)) != -1) {
      //获取数据进行处理
      String message = new String(bytes, 0, len,"UTF-8");
    }
    // socket、server，流关闭操作，省略不表
  }
}

markdown复制代码* 我会通过代码注释的方式介绍每个业务，结合注释阅读更易理解

less复制代码@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface RestLog {
    
    /**
     * 模块名称 
     */
    String module();

    /**
     * 操作
     */
    String action();

    /**
     * 描述
     */
    String describe() default "";
}

复制代码我们业务场景需要记录用户操作的模块，做了什么操作，描述信息为拓展字段，可以根据实际需求增加更多信息。

java复制代码@Data // Lombok注解 
public class LogBean {
    private Long id;
    // 操作userId
    private String userId;
    // 模块
    private String module;
    // 操作
    private String action;
    // 描述信息
    private String describe;
    // 接口地址
    private String api;
    // GET POST DELETE PUT...
    private String method;
    // 接口参数信息
    private String paramJson;
    // 操作时间
    private Date restTime;
}

scss复制代码@Aspect
@Component
public class RestLogAspect {

    private static final Logger LOG = LoggerFactory.getLogger(RestOperationLogAspect.class);
    
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    /**
     * 生成日志后发送的目标topic
     */
    @Value("${rest-log.topic:}")
    private String topic;

    /**
     * 切面
     */
    @Pointcut("@annotation(com.demo.RestLog)")
    private void restLogCut() {
        // 操作日志切面
    }

    /**
     * 执行后日志存储操作
     * 
     * @param joinPoint
     */
    @After("restLogCut()")
    public void after(JoinPoint joinPoint) {
        try {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            // 获取注解对象
            OperationLog annotation = method.getAnnotation(RestLog.class);
            // 获取请求对象 HttpServletRequest
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
            // 请求经过网关 鉴权通过 网关会像请求头中添加userId信息
            String userId = request.getHeader("Auth-Userid");
            if(userId == null) {
                // 内部请求不记录日志 微服务之间接口不仅仅给前端调用 服务间也会有业务调用 服务间调用不会经过网关 也就不会有用户信息
                return;
            }
            // 获取参数名称
            String[] names = signature.getParameterNames();
            // 获取参数值
            Object[] args = joinPoint.getArgs();
            // 将接口请求参数封装成json 便于存储及解析
            JSONObject paramJson = new JSONObject();
            for(int i = 0; i <names.lenth; i++) {
                paramJson.put(names[i], args[i]);
            }
            // 创建日志对象 用于传输日志信息
            LogBean logBean = new LogBean();
            logBean.setUserId(userId);
            logBean.setModule(annotation.module());
            logBean.setAction(annotation.action());
            logBean.setDescribe(annotation.describe());
            logBean.setApi(request.getRequestURI());
            logBean.setMethod(request.getMethod());
            logBean.setParamJson();
            logBean.setRestTime(new Date());
            // 判断是否配置发送的topic 配置了则进行发送
            if(StringUtils.isNotBlank(topic)) {
                // 将日志内容发送到kafka
                kafkaTemplate.send(topic, JSONObject.toJSONString(logBean));
            }
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }
}

xml复制代码<dependency>
   <groupId>com.demo</groupId>
   <artifactId>rest-log-spring-boot-start</artifactId>
   <version>0.0.1-SNAPSHOT</version>
</dependency>

less复制代码rest-log:
  topic: rest_log

java复制代码@RestController
@RequestMapping("/demo")
public class DemoController {
    @PostMapping
    @RestLog(module = "测试模块"， action = "新增"， describe = "这是一个描述")
    public void add(@RequestBody Demo demo) {
        // 省略实现
    }
}

java复制代码@Service
public class LogListener {
    @KafkaListener(topics = "iot-original-history-message", containerFactory = "batchConsumerFactory")
    public void listener(List<ConsumerRecord<String, String>> records) {
        // 遍历记录 实现存储业务即可 省略
    }
}