DEV Community: Keith

The most easiest SpringCloud tutorial ever | Chapter 2: Service consumer (rest+ribbon) (Finchley version)

Keith — Mon, 25 Jul 2022 01:53:44 +0000

in the previous article, I talked about the registration and registration of services. In the microservice architecture, the discovery department is serviced independently, and the communication between services and services is based on http restful. Spring cloud has business service invocation methods, one is ribbon+template, the other is ribbon+rest.

1. Introduction to ribbon
Ribbon is a client side load balancer which gives you a lot of control over the behaviour of HTTP and TCP clients. Feign already uses Ribbon, so if you are using @FeignClient then this section also applies.
Ribbon is a load balancing client that can well control some behaviors of http and tcp. Feign integrates ribbon by default.
ribbon already implements these configuration beans by default :

IClientConfig ribbonClientConfig: DefaultClientConfigImpl
IRule ribbonRule: ZoneAvoidanceRule
IPing ribbonPing: NoOpPing
ServerList ribbonServerList: ConfigurationBasedServerList
ServerListFilter ribbonServerListFilter: ZonePreferenceServerListFilter
ILoadBalancer ribbonLoadBalancer: ZoneAwareLoadBalancer
2.Preparations
This article is based on the project of the previous article, start the eureka-server project; start the service-hi project, its port is 8762; change the port of the service-hi configuration file to 8763, and start it, then you will Discovery: service-hi has registered 2 instances in eureka-server, which is equivalent to a small cluster.

3. Build a service consumer
Create a new spring-boot project and name it: service-ribbon;
In its pom.xml it inherits the parent pom file and introduces the following dependencies:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<groupId>com.forezp</groupId>
    <artifactId>service-ribbon</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
<name>service-ribbon</name>
    <description>Demo project for Spring Boot</description>
<parent>
        <groupId>com.forezp</groupId>
        <artifactId>sc-f-chapter2</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
    </dependencies>
</project>

In the configuration file of the project, the registry address of the specified service is http://localhost:8761/eureka/, the program name is service-ribbon, and the program port is 8764. The configuration file application.yml is as follows:

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 8764
spring:
  application:
    name: service-ribbon

In the startup class of the project, register with the service center through @EnableDiscoveryClient; and inject a bean: restTemplate into the ioc of the program; and use the @LoadBalanced annotation to indicate that this restRemplate enables load balancing.

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
public class ServiceRibbonApplication {
public static void main(String[] args) {
        SpringApplication.run( ServiceRibbonApplication.class, args );
    }
@Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Write a test class HelloService, and consume the “/hi” interface of the service-hi service through the restTemplate injected into the ioc container. Here we directly replace the specific url address with the program name. In the ribbon, it will be based on the service name. Select a specific service instance, and replace the service name with the specific url when requesting according to the service instance. The code is as follows:

@Service
public class HelloService {
@Autowired
    RestTemplate restTemplate;
public String hiService(String name) {
        return restTemplate.getForObject("http://SERVICE-HI/hi?name="+name,String.class);
    }
}

Write a controller and use the method of calling HelloService in the controller. The code is as follows

@RestController
public class HelloControler {
@Autowired
    HelloService helloService;
@GetMapping(value = "/hi")
    public String hi(@RequestParam String name) {
        return helloService.hiService( name );
    }
}

Visit http://localhost:8764/hi?name=forezp multiple times on the browser, and the browser alternately displays:

hi forezp,i am from port:8762
hi forezp,i am from port:8763

This shows that when we call the restTemplate.getForObject(“http://SERVICE-HI/hi?name=”+name,String.class) method, we have done load balancing and accessed service instances on different ports.
4. the structure at this moment

A service registry, eureka server, port 8761

The service-hi project ran two instances with ports 8762 and 8763, which were registered with the service registry respectively.
The sercvice-ribbon port is 8764, registered with the service registry

When sercvice-ribbon calls the hi interface of service-hi through restTemplate, because of load balancing with ribbon, it will call the hi interface of service-hi: 8762 and 8763 ports in turn;

The Pageable object of Spring Data JPA implements paging of the queried list

Keith — Thu, 21 Jul 2022 01:22:23 +0000

Pageable object

Using the Pageable object of Spring Data JPA can perform database query and paging. This implementation has been introduced in many blogs, so I won’t list it anymore. You can refer to the link：
https://www.tianmaying.com/tutorial/spring-jpa-page-sort
But there is a situation that pageable cannot paginate the list results of the queried data, which is almost unavoidable in actual development. For many complex businesses, for simplifying development or considering practical reasons, it is impossible to achieve the requirements through a sql query , it will definitely filter the queried list data, and the paging function of the pageable object is invalid at this time, refer to the code.

List<Impianto> impiantos = myService.findMyMethod(); // returned 30 objects 
    Page<Impianto> pageImpianto = new PageImpl<Impianto>(impiantos, pageable, impiantos.size());

This implementation cannot achieve paging.

According to the spring data jpa author:

Spring Data repositories support pagination on query methods by simply declaring a parameter of type Pageable to make sure they’re only reading the data necessary for the requested Page.
The pageable object is only a basic implementation of paging, and cannot achieve paging of the queried list results. In my opinion, this implementation has almost no practical engineering significance. It is recommended not to use pageable objects for paging in actual project development. If you have different opinions, you can leave a message for discussion.
For this reason, if the pageable object wants to achieve paging, it can only process the data manually. The sample code is as follows:

if (pageable.getOffset() > ucShopCourseBizPojoList.size()) {
    long total = 0L;
    PageImpl<UcShopCourseBizPojo> emptyPage = new PageImpl<>(Lists.newArrayList(), pageable, total);
    resultDo.setResult(emptyPage);
    return resultDo;
}

if (pageable.getOffset() <= ucShopCourseBizPojoList.size() && pageable.getOffset() + pageable.getPageSize() > ucShopCourseBizPojoList.size()) {
    List<UcShopCourseBizPojo> bizPojos = ucShopCourseBizPojoList.subList(pageable.getOffset(), ucShopCourseBizPojoList.size());
    PageImpl<UcShopCourseBizPojo> pPage = new PageImpl<>(bizPojos, pageable, ucShopCourseBizPojoList.size());
    resultDo.setResult(pPage);
    return resultDo;
}

List<UcShopCourseBizPojo> ucShopCourseBizPojos = ucShopCourseBizPojoList.subList(pageable.getOffset(), pageable.getOffset() + pageable.getPageSize());

PageImpl<UcShopCourseBizPojo> pPage = new PageImpl<>(ucShopCourseBizPojos, pageable, ucShopCourseBizPojoList.size());

ucShopCourseBizPojoList is the list to be paginated.

How to modify the MTU of the VPN connection to solve the problem of frequent disconnections and pages that cannot be opened

Keith — Thu, 30 Jun 2022 03:00:38 +0000

How to modify the MTU of the VPN connection to solve the problem of frequent disconnections and pages that cannot be opened
MTU is the maximum transmission unit, which refers to the maximum packet size that can pass through a certain layer of a communication protocol. Why do you need to modify the MTU? Most devices originally support automatic MTU negotiation through the ICMP protocol. But unfortunately, more and more networks block ICMP transmission, which makes the function of MTU auto-negotiation impossible. An incorrect MTU will cause many problems: • Repeatedly dropped connections • Sudden congestion during large data transfers • Pages that won't open, or open slowly • Parts of the page content or styles are lost.
How to modify the MTU of the VPN connection to solve the problem of frequent disconnections and pages that cannot be opened.
MTU introduction: MTU is the maximum transmission unit, which refers to the maximum packet size that can pass through a certain layer of a communication protocol.
Why do you need to modify the MTU
Most devices natively support MTU auto-negotiation via the ICMP protocol.
But unfortunately, more and more networks block ICMP transmission, which makes the function of MTU auto-negotiation impossible. Incorrect MTU will cause many problems:
• Repeatedly disconnected connections
• Sudden congestion when a large amount of data is transmitted
• The page does not open, or opens slowly
• Part of the page content or style is missing
No problems, no need to modify: If you do not encounter any of the above problems, it means that your current network environment has perfectly supported MTU auto-negotiation, and it is recommended not to modify any settings.
How to modify MTU
•Windows
•Mac OS X
•Linux
•iPhone, iPad, Android modify MTU
Windows 8 and Windows 7 modify MTU
On Windows 8 and Windows 7, you can permanently modify the MTU of a VPN connection by using the following methods, and you do not need to set it again after reconnecting or restarting the computer in the future.

Connect to the VPN whose MTU you want to modify
Open a command prompt with administrator privileges, enter the following command in it, it will list all network connections (including VPN connections) in your system netsh interface ipv4 show subinterfaces
Find the VPN name you are connected to in the returned information

4. Enter the following command to modify and save the MTU of this VPN connection. (Please modify the VPN connection name in the following command to the VPN connection of your choice.)

Mac OS X modify MTU
Because OS X adjusts the VPN's MTU based on the MTU of your network connection (WiFi or Ethernet). Therefore, you only need to reduce the MTU of the network connection to reduce the MTU of the VPN.
Proceed as follows:

Open System Preferences
Click Network
In the list on the left, select your network connection. Choose WiFi when you usually use WiFi, and choose Ethernet when you usually use a network cable.
Click the Advanced button on the right
Select the Hardware tab
Select Manual for configuration, select Custom for MTU, enter 1328 in the following, which is right, click Save.
When the interface returns to the network connection, click the Apply button in the lower right corner.
If you are on WiFi, click to turn off WiFi and then re-enable it. If you are connected by a network cable, unplug the network cable and plug it back in again.

In this way, when connecting to the VPN, the MTU of the VPN will be the smaller 1280.

Linux modify MTU

Under Linux, only connections established manually under /etc/ppp/peers can modify mtu and mru through configuration files. Connections established using NetworkManager, on the other hand, ignore the MTU setting in the configuration file.
You can use the following command to temporarily modify the MTU after connecting, but this modification will be invalid after the connection is disconnected or the system is restarted.
sudo ifconfig ppp0 mtu 1280

iPhone, iPad, Android modify MTU
Due to the limitation of the operating system, the MTU cannot be modified temporarily, or the modification method is very complicated.
If these devices cannot use PPTP due to MTU reasons, you can try L2TP instead.

The solution to modifying memory parameters in Idea under Mac computer does not work

Keith — Wed, 22 Jun 2022 00:56:48 +0000

When using idea, if multiple projects are opened at the same time, the memory is often full, which leads to abnormal freezes, and sometimes prompts memory overflow. At this time, it can be improved by increasing the value of Xmx. But how should the Xmx value be adjusted? Why does someone modify the Xmx value but it doesn’t take effect? This article will explain in detail.

1.Ineffective method

Many of the methods found on the Internet to guide you to adjust Xmx are generally as follows:
1.1 Right-click on the application idea — display package contents:

1.2 Then open idea.vmoptions under the bin, modify Xms, Xmx and save, restart idea.

But there should still be many friends who found that this operation has no effect, the idea is still stuck, and the fan is still whirring.
1.3 How to check whether the setting takes effect

In fact, you can judge whether the setting takes effect by looking at the two numbers in the lower right corner of the idea, as shown in the figure:

Here 989 is the maximum available memory, Xmx (the idea itself should occupy a small part), and 862 is the used memory.
If this number is not displayed in your lower right corner, you can set it by clicking “Intellij IDEA” — “Preferences” — “Appearance” in the upper right corner,
Check “Show memory indicator”, ok to save.

2. Reasons for ineffectiveness
2.1 What is the reason for the modification not taking effect?
First of all, confirm whether you have restarted the idea. The restart requires you to close all the idea windows and then open the idea.
If you are sure that it does not take effect after restarting, then there is only one reason: the modified file is not the file that idea actually uses.
2.2 Find the correct configuration

If you want to know which configuration file your idea allows, you can find Contents — the idea executable file under MacOS and double-click to run it

You will see that the path of the idea startup loading configuration file is as follows:

The configuration file used by my idea is: /Users/rcm/Library/Preferences/IdeaIC2018.1/idea.vmoptions
2.3 Modify the correct configuration

By going to the folder command, you can directly find this file and modify it. After modifying and saving, restart the idea to take effect.

My modified configuration is as follows:

-Xms1024m
-Xmx2048m
-XX:ReservedCodeCacheSize=1024m
-XX:+UseCompressedOops
-Dfile.encoding=UTF-8
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-ea
-Dsun.io.useCanonCaches=false
-Djava.net.preferIPv4Stack=true
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-Xverify:none

-XX:ErrorFile=$USER_HOME/java_error_in_idea_%p.log
-XX:HeapDumpPath=$USER_HOME/java_error_in_idea.hprof

The three main parameters modified:

Xms1024m -Xmx2048m -XX:ReservedCodeCacheSize=1024m

3. A more convenient method
Of course, you can also set it up in an easier way:

Click Help — Edit Custom VM Options , modify it in the open file, and restart the idea after modification

Encryption raised an exception

Keith — Wed, 15 Jun 2022 00:43:53 +0000

script-test:
[echo] Testing encrypt.sh
[exec] Exception in thread “main” org.jasypt.exceptions.EncryptionOperationNotPossibleException: Encryption raised an exception. A possible cause is you are using strong encryption algorithms and you have not installed the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files in this Java Virtual Machine
[exec] at org.jasypt.encryption.pbe.StandardPBEByteEncryptor.handleInvalidKeyException(StandardPBEByteEncryptor.java:1073)
[exec] at org.jasypt.encryption.pbe.StandardPBEByteEncryptor.encrypt(StandardPBEByteEncryptor.java:924)
[exec] at org.jasypt.encryption.pbe.StandardPBEStringEncryptor.encrypt(StandardPBEStringEncryptor.java:642)
[exec] at azkaban.crypto.CryptoV1_1.encrypt(CryptoV1_1.java:42)
[exec] at azkaban.crypto.Crypto.encrypt(Crypto.java:49)
[exec] at azkaban.crypto.EncryptionCLI.main(EncryptionCLI.java:58)

It was found that the error was because jdk did not have jce, so it was installed.

How to Install JCE

Go to the Oracle Java SE download page http://www.oracle.com/technetwork/java/javase/downloads/index.html
Scroll down … Under “Additional Resources” section you will find “Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy File”
Download the version that matches your installed JVM E.g. UnlimitedJCEPolicyJDK7.zip
Unzip the downloaded zip
Copy local_policy.jar and US_export_policy.jar to the $JAVA_HOME/jre/lib/security (Note: these jars will be already there so you have to overwrite them)
Then restart your application to get rid of this exception.

http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

The easiest SpringCloud tutorial ever | Chapter 1: Service registration and discovery Eureka (Finchley version)

Keith — Wed, 01 Jun 2022 09:16:32 +0000

Introduction to spring cloud
Spring Cloud provides developers with tools to quickly build distributed systems, including configuration management, service discovery, circuit breakers, routing, micro-agents, event buses, global locks, decision campaigns, distributed sessions, and more. It runs in a simple environment and can run on the developer’s computer. In addition, spring cloud is based on springboot, so you need to have a certain understanding of spring boot in development.
Create a service registry
Here, I use Eureka as the component for service registration and discovery.

2.1 First create a maven main project.

First create a main Maven project and introduce dependencies in its pom file. The spring Boot version is 2.0.3.RELEASE, and the Spring Cloud version is Finchley.RELEASE. This pom file acts as a parent pom file and plays a role in dependent version control, and other module projects inherit the pom.

This series of articles all adopt this mode, and the pom of other articles is the same as this pom. To explain again, it will not be introduced again in the future. code show as below:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<groupId>com.forezp</groupId>
    <artifactId>sc-f-chapter1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
<name>sc-f-chapter1</name>
    <description>Demo project for Spring Boot</description>
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        <relativePath/>
    </parent>
<modules>
        <module>eureka-server</module>
        <module>service-hi</module>
    </modules>
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    </properties>
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.2 Then create 2 model projects

One model project serves as the service registry, namely Eureka Server, and the other serves as Eureka Client.

The following takes creating a server as an example to describe the creation process in detail:

Right-click the project->create model->select spring initialir as shown below:

Next step -> select cloud discovery->eureka server, and then continue to the next step.

After the project is created, its pom.xml inherits the parent pom file and introduces the dependency of spring-cloud-starter-netflix-eureka-server. The code is as follows:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<groupId>com.forezp</groupId>
    <artifactId>eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
<name>eureka-server</name>
    <description>Demo project for Spring Boot</description>
<parent>
        <groupId>com.forezp</groupId>
        <artifactId>sc-f-chapter1</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
</project>

2.3 To start a service registry
only one annotation @EnableEurekaServer is required. This annotation needs to be added to the startup application class of the spring boot project:

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
public static void main(String[] args) {
        SpringApplication.run( EurekaServerApplication.class, args );
    }
}

2.4 eureka is a highly available component. It has no back-end cache. After each instance is registered, it needs to send a heartbeat to the registry (so it can be done in memory). By default, the erureka server is also an eureka client, and one must be specified. server. The configuration file application.yml of eureka server:

server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
spring:
  application:
    name: eurka-server

Use eureka.client.registerWithEureka: false and fetchRegistry: false to indicate that you are an eureka server.

2.5 eureka server has an interface, start the project, open the browser to access:
http://localhost:8761 , the interface is as follows:

No application available No service was found..._
Because of course no service can be discovered without a registered service.

Create a service provider (eureka client) When the client registers with the server, it provides some metadata such as host and port, URL, homepage, etc. The Eureka server receives heartbeat messages from each client instance. If the heartbeat times out, the instance is usually removed from the registration server.

The creation process is similar to the server, and the pom.xml is created as follows:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<groupId>com.forezp</groupId>
    <artifactId>service-hi</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
<name>service-hi</name>
    <description>Demo project for Spring Boot</description>
<parent>
        <groupId>com.forezp</groupId>
        <artifactId>sc-f-chapter1</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Indicate yourself as an eurekaclient by annotating @EnableEurekaClient.

@SpringBootApplication
@EnableEurekaClient
@RestController
public class ServiceHiApplication {
public static void main(String[] args) {
        SpringApplication.run( ServiceHiApplication.class, args );
    }
@Value("${server.port}")
    String port;
@RequestMapping("/hi")
    public String home(@RequestParam(value = "name", defaultValue = "forezp") String name) {
        return "hi " + name + " ,i am from port:" + port;
    }
}

Only @EnableEurekaClient is not enough, you also need to indicate the address of your own service registry in the configuration file. The application.yml configuration file is as follows:

server:
  port: 8762
spring:
  application:
    name: service-hi
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

It is necessary to specify spring.application.name, which is very important. In the future, mutual calls between services and services are generally based on this name.
Start the project and open http://localhost:8761, which is the URL of the eureka server:

You will find that a service has been registered in the service, the service name is SERVICE-HI, and the port is 7862

Then open http://localhost:8762/hi?name=forezp and you will see on your browser:

hi forezp,i am from port:8762

Use ScheduledExecutorService to implement delayed tasks — delayed video release

Keith — Tue, 31 May 2022 00:56:56 +0000

Using ScheduledExecutorService can implement timed tasks (such as the function of timed release)

First define local variables in the class

ScheduledExecutorService service = Executors.newScheduledThreadPool(50);

Executors.newScheduledThreadPool(50); Factory pattern is used here.

factory pattern

It is mainly to provide a transition interface for creating objects, so as to shield and isolate the specific process of creating objects and achieve the purpose of improving flexibility.

@PostMapping("/ops/scheduled/publish")
    public ResponseResult scheduledPublish(@RequestBody ScheduleVideoDto dto) {
        List<Integer> vids = dto.getVids();
        if (vids.isEmpty()){
            return ResponseResult.of().withErrorMessage("Failed to publish video, please select a video to publish");
        }
        Date pushTime = dto.getPushTime();
        if (pushTime==null){
            return ResponseResult.of().withErrorMessage("Failed to publish the video, please re-select the publishing time");
        }
        for (int i = 0; i< vids.size();i++){
            int status =  videoService.getStatusById(vids.get(i));
            if (status==1) vids.remove(vids.get(i));
        }
        if (vids.isEmpty()){
            return ResponseResult.of().withErrorMessage("Failed to publish video, the selected videos are all published");
        }
        long delay = pushTime.getTime() - System.currentTimeMillis();
        vids.forEach(vid->{
            videoService.updatePushTime(vid,pushTime);
            service.schedule(() -> videoService.publish(vid), delay, TimeUnit.MILLISECONDS);
        });
        return ResponseResult.of();
    }

Pass in the release time PushTime in the dto passed in the interface

long delay = pushTime.getTime() - System.currentTimeMillis();
#The release time minus the current time is the delay time delay

Calling ScheduledExecutorService

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay, TimeUnit unit);

api method

It can realize the function of publishing video at a fixed time

Java 8 lambda function implements deduplication of lists based on property values

Keith — Wed, 18 May 2022 05:44:20 +0000

If your project uses java8, there is a very simple way to deal with the deduplication according to the value of a certain attribute in the list, which is to use lamba function. The example code is as follows:

List<UcShopCourseBizPojo> unique = ucShopCourseBizPojoList.stream().collect(
 collectingAndThen(
 toCollection(() -> new TreeSet<>(comparingLong(UcShopCourseBizPojo::getId))), ArrayList::new));

The comparingLong method is because in the pojo class UcShopCourseBizPojo, the duplication is removed according to the id, and the data type of the id attribute is Long. This method can be replaced by a more general method. The example code is as follows:

List<UcShopCourseBizPojo> sLists = shopCourseLists.stream().collect(
        Collectors.collectingAndThen(Collectors.toCollection(
                () -> new TreeSet<>(Comparator.comparing(c -> c.getShopId()))), ArrayList::new)
);

However, this method of filtering weight has a disadvantage, which is, the obtained list may return random results each time, such as obtaining a list of store courses and deduplicating courses with the same shopid. If the shopid of two courses is the same, it may be called every time. Sometimes I will return to this course, and I will return to another course. I don’t know what the underlying cause is. This method is for reference only. If you know the reason, you can leave a message~

‘The client noticed that the server is not a supported distribution of Elasticsearch‘ error and solution

Keith — Mon, 16 May 2022 23:44:19 +0000

The django project is running very well, but suddenly the interface query error.

{
 “code”: 400102,
 “message”: “请求错误”,
 “data”: {
 “detail”: “The client noticed that the server is not a supported distribution of Elasticsearch”
 }
}

Search Baidu there is no result, just search Google Query to the news link

Links:
https://www.theregister.com/2021/08/09/elasticsearch_python_client_change/

The main meaning is that in order to fight aws, es no longer supports the apach 2.0 open source protocol in the new version.
https://www.oschina.net/news/154014/aws-fork-clients-of-elasticsearch

Therefore, it is necessary to reduce the dependency version of the es client of the python project or adopt the open source version of opensearch newly pulled by aws. However, opensearch can not be used in the production environment
https://aws.amazon.com/cn/elasticsearch-service/the-elk-stack/what-is-opensearch/

So modify the es version of the specified project in pipfile.rch can not be used in the production environment

Restart the build, the problem is solved!

Springboot annotation @Cacheable custom file set key to set expiration time and configure it in the configuration

Keith — Sun, 15 May 2022 06:23:26 +0000

The configuration of the Springboot RedisCacheManager class specifies the expiration time of the key and configures it in the configuration file
purpose and effect

RedisCache is configured in springBoot. When the @Cacheable annotation is used, the default is redisCache. By setting the expiration time of different keys in the configuration file, the effect of customizing the key expiration time can be achieved.
plan
step1

Create a new Map class to store the key to be set

@ConfigurationProperties
public class Properties {

 private final Map<String, Duration> initCaches = Maps.newHashMap();

 public Map<String, Duration> getInitCaches() {
 return initCaches;
 }
}

step 2

Write the cacheManager in the redis configuration class and put the map set into it

@Autowired
private Properties properties;

@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10)).disableCachingNullValues();

    RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);

    ImmutableSet.Builder<String> cacheNames = ImmutableSet.builder();
    ImmutableMap.Builder<String, RedisCacheConfiguration> cacheConfig = ImmutableMap.builder();
    for (Map.Entry<String, Duration> entry : properties.getInitCaches().entrySet()) {
        cacheNames.add(entry.getKey());
        cacheConfig.put(entry.getKey(), defaultCacheConfig.entryTtl(entry.getValue()));
    }

    return RedisCacheManager.builder(redisCacheWriter)
            .cacheDefaults(defaultCacheConfig)
            .initialCacheNames(cacheNames.build())
            .withInitialCacheConfigurations(cacheConfig.build())
            .build();
}

step3

By configuring the expiration time of the relevant key in the Springboot yml file, you can specify the expiration time of the value of @Cacheable

//Fake code
@Cacheable(cacheNames = "fooboo", key = "#xxx", unless = "#result == null")
public void fooboo(String xxx){}

set in the applicaion.yml file

initCaches:
  fooboo: 10m
  fooboo1: 1h

Then the value of fooboo in the redis cache expires in 10 minutes, and the value of fooboo1 expires in 1 hour